From 5942bd6f73499f198b23975b8d7b8df1383934d8 Mon Sep 17 00:00:00 2001 From: Marcus Brinkmann Date: Sun, 29 Sep 2002 15:11:59 +0000 Subject: 2002-09-29 Marcus Brinkmann * mount.c (mount_root): Add parenthesis for post-decrement (even though it is only used as an lvalue here). Increment P after using it in the macro, not within. * rpc.c (initialize_rpc, conduct_rpc): Likewise. * ops.c (process_returned_stat, process_wcc_stat, netfs_validate_stat, netfs_attempt_chown, netfs_attempt_chmod, netfs_attempt_utimes, netfs_attempt_set_size, netfs_attempt_statfs, netfs_attempt_read, netfs_attempt_write, verify_nonexistent, netfs_attempt_lookup, netfs_attempt_mkdir, netfs_attempt_rmdir, netfs_attempt_link, netfs_attempt_create_file, netfs_attempt_unlink, netfs_attempt_rename, netfs_attempt_readlink, netfs_report_access, netfs_check_open_permissions): Likewise. (fetch_directory): Likewise. Also use memcpy instead bcopy. * cache.c (recache_handle): Likewise. * nfs.c (xdr_encode_data, xdr_encode_sattr_mode, xdr_encode_sattr_ids, xdr_encode_sattr_size, xdr_encode_sattr_times, xdr_encode_create_state, xdr_encode_sattr_stat, xdr_decode_64bit, xdr_decode_fattr): Likewise. (xdr_decode_string): Likewise. Also use memcpy instead bcopy. (xdr_decode_fhandle): Likewise. Also use memcpy instead bcopy. --- nfs/ChangeLog | 25 +++++ nfs/cache.c | 35 +++--- nfs/mount.c | 29 ++--- nfs/nfs.c | 338 ++++++++++++++++++++++++++++++++-------------------------- nfs/ops.c | 243 +++++++++++++++++++++++++---------------- nfs/rpc.c | 110 ++++++++++--------- 6 files changed, 457 insertions(+), 323 deletions(-) (limited to 'nfs') diff --git a/nfs/ChangeLog b/nfs/ChangeLog index 4c037b37..3d2f40d7 100644 --- a/nfs/ChangeLog +++ b/nfs/ChangeLog @@ -1,3 +1,28 @@ +2002-09-29 Marcus Brinkmann + + * mount.c (mount_root): Add parenthesis for post-decrement (even + though it is only used as an lvalue here). Increment P after + using it in the macro, not within. + * rpc.c (initialize_rpc, conduct_rpc): Likewise. + * ops.c (process_returned_stat, process_wcc_stat, + netfs_validate_stat, netfs_attempt_chown, netfs_attempt_chmod, + netfs_attempt_utimes, netfs_attempt_set_size, + netfs_attempt_statfs, netfs_attempt_read, netfs_attempt_write, + verify_nonexistent, netfs_attempt_lookup, netfs_attempt_mkdir, + netfs_attempt_rmdir, netfs_attempt_link, + netfs_attempt_create_file, netfs_attempt_unlink, + netfs_attempt_rename, netfs_attempt_readlink, netfs_report_access, + netfs_check_open_permissions): Likewise. + (fetch_directory): Likewise. Also use memcpy instead bcopy. + * cache.c (recache_handle): Likewise. + * nfs.c (xdr_encode_data, xdr_encode_sattr_mode, + xdr_encode_sattr_ids, xdr_encode_sattr_size, + xdr_encode_sattr_times, xdr_encode_create_state, + xdr_encode_sattr_stat, xdr_decode_64bit, xdr_decode_fattr): + Likewise. + (xdr_decode_string): Likewise. Also use memcpy instead bcopy. + (xdr_decode_fhandle): Likewise. Also use memcpy instead bcopy. + 2002-05-13 Roland McGrath * ops.c (register_fresh_stat): Set NP->nn_translated appropriately. diff --git a/nfs/cache.c b/nfs/cache.c index 3cdb527f..8f87f5d0 100644 --- a/nfs/cache.c +++ b/nfs/cache.c @@ -1,5 +1,5 @@ -/* Node cache management for NFS client implementation - Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc. +/* cache.c - Node cache management for NFS client implementation. + Copyright (C) 1995, 1996, 1997, 2002 Free Software Foundation, Inc. Written by Michael I. Bushnell, p/BSG. This file is part of the GNU Hurd. @@ -23,14 +23,15 @@ #include #include -/* Hash table containing all the nodes currently active. - XXX Was 512, however, a prime is much nice for the hash - function. 509 is nice as not only is it prime, it keeps - the array within a page or two */ +/* Hash table containing all the nodes currently active. XXX Was 512, + however, a prime is much nicer for the hash function. 509 is nice + as not only is it prime, it also keeps the array within a page or + two. */ #define CACHESIZE 509 static struct node *nodehash [CACHESIZE]; -/* Compute and return a hash key for NFS file handle DATA of LEN bytes. */ +/* Compute and return a hash key for NFS file handle DATA of LEN + bytes. */ static inline int hash (int *data, size_t len) { @@ -96,15 +97,15 @@ lookup_fhandle (void *p, size_t len, struct node **npp) *npp = np; } -/* Package holding args to forked_node_delete. */ +/* Package holding args to forked_node_delete. */ struct fnd { struct node *dir; char *name; }; -/* Worker function to delete nodes that don't have any more local references - or links. */ +/* Worker function to delete nodes that don't have any more local + references or links. */ any_t forked_node_delete (any_t arg) { @@ -121,7 +122,7 @@ forked_node_delete (any_t arg) /* Called by libnetfs when node NP has no more references. (See for details. Just clear its local state and remove it from the hash table. Called and expected to leave with - NETFS_NODE_REFCNT_LOCK held. */ + NETFS_NODE_REFCNT_LOCK held. */ void netfs_node_norefs (struct node *np) { @@ -141,8 +142,9 @@ netfs_node_norefs (struct node *np) np->nn->dead_name = 0; netfs_nput (np); - /* Do this in a separate thread so that we don't wait for it; - it acquires a lock on the dir, which we are not allowed to do. */ + /* Do this in a separate thread so that we don't wait for it; it + acquires a lock on the dir, which we are not allowed to + do. */ cthread_detach (cthread_fork (forked_node_delete, (any_t) args)); /* Caller expects us to leave this locked... */ @@ -162,7 +164,7 @@ netfs_node_norefs (struct node *np) /* Change the file handle used for node NP to be the handle at P. Make sure the hash table stays up to date. Return the address - after the handle. The lock on the node should be held. */ + after the handle. The lock on the node should be held. */ int * recache_handle (int *p, struct node *np) { @@ -172,7 +174,10 @@ recache_handle (int *p, struct node *np) if (protocol_version == 2) len = NFS2_FHSIZE; else - len = ntohl (*p++); + { + len = ntohl (*p); + p++; + } /* Unlink it */ spin_lock (&netfs_node_refcnt_lock); diff --git a/nfs/mount.c b/nfs/mount.c index 3ead073f..07dbb19b 100644 --- a/nfs/mount.c +++ b/nfs/mount.c @@ -116,7 +116,7 @@ mount_root (char *name, char *host) argument is either "tcp" or "udp" Thus, is this backwards (as service_name suggests)? If so, should it read: s = getservbyname (pmap_service_name, "udp"); - or is there something I am missing here? */ + or is there something I am missing here? */ s = getservbyname ("sunrpc", pmap_service_name); if (s) pmapport = s->s_port; @@ -158,14 +158,15 @@ mount_root (char *name, char *host) return 0; } - *p++ = htonl (MOUNTPROG); - *p++ = htonl (MOUNTVERS); - *p++ = htonl (IPPROTO_UDP); - *p++ = htonl (0); + *(p++) = htonl (MOUNTPROG); + *(p++) = htonl (MOUNTVERS); + *(p++) = htonl (IPPROTO_UDP); + *(p++) = htonl (0); err = conduct_rpc (&rpcbuf, &p); if (!err) { - port = ntohl (*p++); + port = ntohl (*p); + p++; addr.sin_port = htons (port); } else if (mount_port) @@ -204,7 +205,8 @@ mount_root (char *name, char *host) /* XXX Protocol spec says this should be a "unix error code"; we'll pretend that an NFS error code is what's meant; the numbers match anyhow. */ - err = nfs_error_trans (htonl (*p++)); + err = nfs_error_trans (htonl (*p)); + p++; if (err) { error (0, err, name); @@ -235,13 +237,16 @@ mount_root (char *name, char *host) error (0, errno, "rpc"); goto error_with_rpcbuf; } - *p++ = htonl (NFS_PROGRAM); - *p++ = htonl (NFS_VERSION); - *p++ = htonl (IPPROTO_UDP); - *p++ = htonl (0); + *(p++) = htonl (NFS_PROGRAM); + *(p++) = htonl (NFS_VERSION); + *(p++) = htonl (IPPROTO_UDP); + *(p++) = htonl (0); err = conduct_rpc (&rpcbuf, &p); if (!err) - port = ntohl (*p++); + { + port = ntohl (*p); + p++; + } else if (nfs_port) port = nfs_port; else diff --git a/nfs/nfs.c b/nfs/nfs.c index 27a3a4fe..2628a570 100644 --- a/nfs/nfs.c +++ b/nfs/nfs.c @@ -1,5 +1,5 @@ -/* XDR frobbing and lower level routines for NFS client - Copyright (C) 1995, 1996, 1997, 1999 Free Software Foundation, Inc. +/* nfs.c - XDR frobbing and lower level routines for NFS client. + Copyright (C) 1995, 1996, 1997, 1999, 2002 Free Software Foundation, Inc. Written by Michael I. Bushnell, p/BSG. This file is part of the GNU Hurd. @@ -24,7 +24,8 @@ #include #include -/* Convert an NFS mode (TYPE and MODE) to a Hurd mode and return it. */ +/* Convert an NFS mode (TYPE and MODE) to a Hurd mode and return + it. */ mode_t nfs_mode_to_hurd_mode (int type, int mode) { @@ -88,7 +89,7 @@ nfs_mode_to_hurd_mode (int type, int mode) return hurdmode; } -/* Convert a Hurd mode to an NFS mode */ +/* Convert a Hurd mode to an NFS mode. */ int hurd_mode_to_nfs_mode (mode_t mode) { @@ -97,7 +98,7 @@ hurd_mode_to_nfs_mode (mode_t mode) return mode & 07777; } -/* Convert a Hurd mode to an NFS type */ +/* Convert a Hurd mode to an NFS type. */ int hurd_mode_to_nfs_type (mode_t mode) { @@ -131,167 +132,167 @@ hurd_mode_to_nfs_type (mode_t mode) /* Each of the functions on this page copies its second arg to *P, converting it to XDR representation along the way. They then - return the address after the copied value. */ + return the address after the copied value. */ -/* Encode an NFS file handle. */ +/* Encode an NFS file handle. */ int * xdr_encode_fhandle (int *p, struct fhandle *fhandle) { if (protocol_version == 2) { - bcopy (fhandle->data, p, NFS2_FHSIZE); + memcpy (p, fhandle->data, NFS2_FHSIZE); return p + INTSIZE (NFS2_FHSIZE); } else return xdr_encode_data (p, fhandle->data, fhandle->size); } -/* Encode uninterpreted bytes. */ +/* Encode uninterpreted bytes. */ int * xdr_encode_data (int *p, char *data, size_t len) { int nints = INTSIZE (len); p[nints] = 0; - *p++ = htonl (len); + *(p++) = htonl (len); memcpy (p, data, len); return p + nints; } -/* Encode a 64 bit integer */ +/* Encode a 64 bit integer. */ int * xdr_encode_64bit (int *p, long long n) { - *p++ = htonl (n & 0xffffffff00000000LL >> 32); - *p++ = htonl (n & 0xffffffff); + *(p++) = htonl (n & 0xffffffff00000000LL >> 32); + *(p++) = htonl (n & 0xffffffff); return p; } -/* Encode a C string. */ +/* Encode a C string. */ int * xdr_encode_string (int *p, char *string) { return xdr_encode_data (p, string, strlen (string)); } -/* Encode a MODE into an otherwise empty sattr. */ +/* Encode a MODE into an otherwise empty sattr. */ int * xdr_encode_sattr_mode (int *p, mode_t mode) { if (protocol_version == 2) { - *p++ = htonl (hurd_mode_to_nfs_mode (mode)); - *p++ = -1; /* uid */ - *p++ = -1; /* gid */ - *p++ = -1; /* size */ - *p++ = -1; /* atime secs */ - *p++ = -1; /* atime usecs */ - *p++ = -1; /* mtime secs */ - *p++ = -1; /* mtime usecs */ + *(p++) = htonl (hurd_mode_to_nfs_mode (mode)); + *(p++) = -1; /* uid */ + *(p++) = -1; /* gid */ + *(p++) = -1; /* size */ + *(p++) = -1; /* atime secs */ + *(p++) = -1; /* atime usecs */ + *(p++) = -1; /* mtime secs */ + *(p++) = -1; /* mtime usecs */ } else { - *p++ = htonl (1); /* set mode */ - *p++ = htonl (hurd_mode_to_nfs_mode (mode)); - *p++ = 0; /* no uid */ - *p++ = 0; /* no gid */ - *p++ = 0; /* no size */ - *p++ = DONT_CHANGE; /* no atime */ - *p++ = DONT_CHANGE; /* no mtime */ + *(p++) = htonl (1); /* set mode */ + *(p++) = htonl (hurd_mode_to_nfs_mode (mode)); + *(p++) = 0; /* no uid */ + *(p++) = 0; /* no gid */ + *(p++) = 0; /* no size */ + *(p++) = DONT_CHANGE; /* no atime */ + *(p++) = DONT_CHANGE; /* no mtime */ } return p; } -/* Encode UID and GID into an otherwise empty sattr. */ +/* Encode UID and GID into an otherwise empty sattr. */ int * xdr_encode_sattr_ids (int *p, u_int uid, u_int gid) { if (protocol_version == 2) { - *p++ = -1; /* mode */ - *p++ = htonl (uid); - *p++ = htonl (gid); - *p++ = -1; /* size */ - *p++ = -1; /* atime secs */ - *p++ = -1; /* atime usecs */ - *p++ = -1; /* mtime secs */ - *p++ = -1; /* mtime usecs */ + *(p++) = -1; /* mode */ + *(p++) = htonl (uid); + *(p++) = htonl (gid); + *(p++) = -1; /* size */ + *(p++) = -1; /* atime secs */ + *(p++) = -1; /* atime usecs */ + *(p++) = -1; /* mtime secs */ + *(p++) = -1; /* mtime usecs */ } else { - *p++ = 0; /* no mode */ - *p++ = htonl (1); /* set uid */ - *p++ = htonl (uid); - *p++ = htonl (1); /* set gid */ - *p++ = htonl (gid); - *p++ = 0; /* no size */ - *p++ = DONT_CHANGE; /* no atime */ - *p++ = DONT_CHANGE; /* no mtime */ + *(p++) = 0; /* no mode */ + *(p++) = htonl (1); /* set uid */ + *(p++) = htonl (uid); + *(p++) = htonl (1); /* set gid */ + *(p++) = htonl (gid); + *(p++) = 0; /* no size */ + *(p++) = DONT_CHANGE; /* no atime */ + *(p++) = DONT_CHANGE; /* no mtime */ } return p; } -/* Encode a file size into an otherwise empty sattr. */ +/* Encode a file size into an otherwise empty sattr. */ int * xdr_encode_sattr_size (int *p, off_t size) { if (protocol_version == 2) { - *p++ = -1; /* mode */ - *p++ = -1; /* uid */ - *p++ = -1; /* gid */ - *p++ = htonl (size); - *p++ = -1; /* atime secs */ - *p++ = -1; /* atime usecs */ - *p++ = -1; /* mtime secs */ - *p++ = -1; /* mtime secs */ + *(p++) = -1; /* mode */ + *(p++) = -1; /* uid */ + *(p++) = -1; /* gid */ + *(p++) = htonl (size); + *(p++) = -1; /* atime secs */ + *(p++) = -1; /* atime usecs */ + *(p++) = -1; /* mtime secs */ + *(p++) = -1; /* mtime secs */ } else { - *p++ = 0; /* no mode */ - *p++ = 0; /* no uid */ - *p++ = 0; /* no gid */ - *p++ = htonl (1); /* size */ + *(p++) = 0; /* no mode */ + *(p++) = 0; /* no uid */ + *(p++) = 0; /* no gid */ + *(p++) = htonl (1); /* size */ p = xdr_encode_64bit (p, size); - *p++ = DONT_CHANGE; /* no atime */ - *p++ = DONT_CHANGE; /* no mtime */ + *(p++) = DONT_CHANGE; /* no atime */ + *(p++) = DONT_CHANGE; /* no mtime */ } return p; } -/* Encode ATIME and MTIME into an otherwise empty sattr. */ +/* Encode ATIME and MTIME into an otherwise empty sattr. */ int * xdr_encode_sattr_times (int *p, struct timespec *atime, struct timespec *mtime) { if (protocol_version == 2) { - *p++ = -1; /* mode */ - *p++ = -1; /* uid */ - *p++ = -1; /* gid */ - *p++ = -1; /* size */ - *p++ = htonl (atime->tv_sec); - *p++ = htonl (atime->tv_nsec / 1000); - *p++ = htonl (mtime->tv_sec); - *p++ = htonl (mtime->tv_nsec / 1000); + *(p++) = -1; /* mode */ + *(p++) = -1; /* uid */ + *(p++) = -1; /* gid */ + *(p++) = -1; /* size */ + *(p++) = htonl (atime->tv_sec); + *(p++) = htonl (atime->tv_nsec / 1000); + *(p++) = htonl (mtime->tv_sec); + *(p++) = htonl (mtime->tv_nsec / 1000); } else { - *p++ = 0; /* no mode */ - *p++ = 0; /* no uid */ - *p++ = 0; /* no gid */ - *p++ = 0; /* no size */ - *p++ = htonl (SET_TO_CLIENT_TIME); /* atime */ - *p++ = htonl (atime->tv_sec); - *p++ = htonl (atime->tv_nsec); - *p++ = htonl (SET_TO_CLIENT_TIME); /* mtime */ - *p++ = htonl (mtime->tv_sec); - *p++ = htonl (mtime->tv_nsec); + *(p++) = 0; /* no mode */ + *(p++) = 0; /* no uid */ + *(p++) = 0; /* no gid */ + *(p++) = 0; /* no size */ + *(p++) = htonl (SET_TO_CLIENT_TIME); /* atime */ + *(p++) = htonl (atime->tv_sec); + *(p++) = htonl (atime->tv_nsec); + *(p++) = htonl (SET_TO_CLIENT_TIME); /* mtime */ + *(p++) = htonl (mtime->tv_sec); + *(p++) = htonl (mtime->tv_nsec); } return p; } -/* Encode MODE, a size of zero, and the specified owner into an otherwise - empty sattr. */ +/* Encode MODE, a size of zero, and the specified owner into an + otherwise empty sattr. */ int * xdr_encode_create_state (int *p, mode_t mode, @@ -299,74 +300,77 @@ xdr_encode_create_state (int *p, { if (protocol_version == 2) { - *p++ = htonl (hurd_mode_to_nfs_mode (mode)); - *p++ = htonl (owner); /* uid */ - *p++ = -1; /* gid */ - *p++ = 0; /* size */ - *p++ = -1; /* atime sec */ - *p++ = -1; /* atime usec */ - *p++ = -1; /* mtime sec */ - *p++ = -1; /* mtime usec */ + *(p++) = htonl (hurd_mode_to_nfs_mode (mode)); + *(p++) = htonl (owner); /* uid */ + *(p++) = -1; /* gid */ + *(p++) = 0; /* size */ + *(p++) = -1; /* atime sec */ + *(p++) = -1; /* atime usec */ + *(p++) = -1; /* mtime sec */ + *(p++) = -1; /* mtime usec */ } else { - *p++ = htonl (1); /* mode */ - *p++ = htonl (hurd_mode_to_nfs_mode (mode)); - *p++ = htonl (1); /* set uid */ - *p++ = htonl (owner); - *p++ = 0; /* no gid */ - *p++ = htonl (1); /* set size */ + *(p++) = htonl (1); /* mode */ + *(p++) = htonl (hurd_mode_to_nfs_mode (mode)); + *(p++) = htonl (1); /* set uid */ + *(p++) = htonl (owner); + *(p++) = 0; /* no gid */ + *(p++) = htonl (1); /* set size */ p = xdr_encode_64bit (p, 0); - *p++ = htonl (SET_TO_SERVER_TIME); /* atime */ - *p++ = htonl (SET_TO_SERVER_TIME); /* mtime */ + *(p++) = htonl (SET_TO_SERVER_TIME); /* atime */ + *(p++) = htonl (SET_TO_SERVER_TIME); /* mtime */ } return p; } -/* Encode ST into an sattr. */ +/* Encode ST into an sattr. */ int * xdr_encode_sattr_stat (int *p, struct stat *st) { if (protocol_version == 2) { - *p++ = htonl (hurd_mode_to_nfs_mode (st->st_mode)); - *p++ = htonl (st->st_uid); - *p++ = htonl (st->st_gid); - *p++ = htonl (st->st_size); - *p++ = htonl (st->st_atime); - *p++ = htonl (st->st_atime_usec); - *p++ = htonl (st->st_mtime); - *p++ = htonl (st->st_mtime_usec); + *(p++) = htonl (hurd_mode_to_nfs_mode (st->st_mode)); + *(p++) = htonl (st->st_uid); + *(p++) = htonl (st->st_gid); + *(p++) = htonl (st->st_size); + *(p++) = htonl (st->st_atime); + *(p++) = htonl (st->st_atime_usec); + *(p++) = htonl (st->st_mtime); + *(p++) = htonl (st->st_mtime_usec); } else { - *p++ = htonl (1); /* set mode */ - *p++ = htonl (hurd_mode_to_nfs_mode (st->st_mode)); - *p++ = htonl (1); /* set uid */ - *p++ = htonl (st->st_uid); - *p++ = htonl (1); /* set gid */ - *p++ = htonl (st->st_gid); - *p++ = htonl (1); /* set size */ + *(p++) = htonl (1); /* set mode */ + *(p++) = htonl (hurd_mode_to_nfs_mode (st->st_mode)); + *(p++) = htonl (1); /* set uid */ + *(p++) = htonl (st->st_uid); + *(p++) = htonl (1); /* set gid */ + *(p++) = htonl (st->st_gid); + *(p++) = htonl (1); /* set size */ p = xdr_encode_64bit (p, st->st_size); - *p++ = htonl (SET_TO_CLIENT_TIME); /* set atime */ - *p++ = htonl (st->st_atime); - *p++ = htonl (st->st_atime_usec * 1000); - *p++ = htonl (SET_TO_CLIENT_TIME); /* set mtime */ - *p++ = htonl (st->st_mtime); - *p++ = htonl (st->st_mtime_usec * 1000); + *(p++) = htonl (SET_TO_CLIENT_TIME); /* set atime */ + *(p++) = htonl (st->st_atime); + *(p++) = htonl (st->st_atime_usec * 1000); + *(p++) = htonl (SET_TO_CLIENT_TIME); /* set mtime */ + *(p++) = htonl (st->st_mtime); + *(p++) = htonl (st->st_mtime_usec * 1000); } return p; } -/* Decode *P into a long long; return the address of the following data. */ +/* Decode *P into a long long; return the address of the following + data. */ int * xdr_decode_64bit (int *p, long long *n) { long long high, low; - high = ntohl (*p++); - low = ntohl (*p++); + high = ntohl (*p); + p++; + low = ntohl (*p); + p++; *n = ((high & 0xffffffff) << 32) | (low & 0xffffffff); return p; } @@ -378,31 +382,46 @@ xdr_decode_fhandle (int *p, struct node **npp) { size_t len; - len = protocol_version == 2 ? NFS2_FHSIZE : ntohl (*p++); - /* Enter into cache */ + if (protocol_version == 2) + len = NFS2_FHSIZE; + else + { + len = ntohl (*p); + p++; + } + /* Enter into cache. */ lookup_fhandle (p, len, npp); return p + len / sizeof (int); } /* Decode *P into a stat structure; return the address of the - following data. */ + following data. */ int * xdr_decode_fattr (int *p, struct stat *st) { int type, mode; - type = ntohl (*p++); - mode = ntohl (*p++); + type = ntohl (*p); + p++; + mode = ntohl (*p); + p++; st->st_mode = nfs_mode_to_hurd_mode (type, mode); - st->st_nlink = ntohl (*p++); - st->st_uid = ntohl (*p++); - st->st_gid = ntohl (*p++); + st->st_nlink = ntohl (*p); + p++; + st->st_uid = ntohl (*p); + p++; + st->st_gid = ntohl (*p); + p++; if (protocol_version == 2) { - st->st_size = ntohl (*p++); - st->st_blksize = ntohl (*p++); - st->st_rdev = ntohl (*p++); - st->st_blocks = ntohl (*p++); + st->st_size = ntohl (*p); + p++; + st->st_blksize = ntohl (*p); + p++; + st->st_rdev = ntohl (*p); + p++; + st->st_blocks = ntohl (*p); + p++; } else { @@ -413,18 +432,28 @@ xdr_decode_fattr (int *p, struct stat *st) p = xdr_decode_64bit (p, &size); st->st_blocks = size / 512; st->st_blksize = read_size < write_size ? read_size : write_size; - major = ntohl (*p++); - minor = ntohl (*p++); + major = ntohl (*p); + p++; + minor = ntohl (*p); + p++; st->st_rdev = makedev (major, minor); } - st->st_fsid = ntohl (*p++); - st->st_ino = ntohl (*p++); - st->st_atime = ntohl (*p++); - st->st_atime_usec = ntohl (*p++); - st->st_mtime = ntohl (*p++); - st->st_mtime_usec = ntohl (*p++); - st->st_ctime = ntohl (*p++); - st->st_ctime_usec = ntohl (*p++); + st->st_fsid = ntohl (*p); + p++; + st->st_ino = ntohl (*p); + p++; + st->st_atime = ntohl (*p); + p++; + st->st_atime_usec = ntohl (*p); + p++; + st->st_mtime = ntohl (*p); + p++; + st->st_mtime_usec = ntohl (*p); + p++; + st->st_ctime = ntohl (*p); + p++; + st->st_ctime_usec = ntohl (*p); + p++; if (protocol_version == 3) { @@ -438,14 +467,15 @@ xdr_decode_fattr (int *p, struct stat *st) } /* Decode *P into a string, stored at BUF; return the address - of the following data. */ + of the following data. */ int * xdr_decode_string (int *p, char *buf) { int len; - len = ntohl (*p++); - bcopy (p, buf, len); + len = ntohl (*p); + p++; + memcpy (buf, p, len); buf[len] = '\0'; return p + INTSIZE (len); } @@ -458,7 +488,7 @@ xdr_decode_string (int *p, char *buf) means superuser), NP (identifying the node we are operating on), and SECOND_GID (specifying another GID the server might be interested in). Allocate at least LEN bytes of space for bulk data in - addition to the normal amount for an RPC. */ + addition to the normal amount for an RPC. */ int * nfs_initialize_rpc (int rpc_proc, struct iouser *cred, size_t len, void **bufp, struct node *np, @@ -469,7 +499,8 @@ nfs_initialize_rpc (int rpc_proc, struct iouser *cred, error_t err; /* Use heuristics to figure out what ids to present to the server. - Don't lie, but adjust ids as necessary to secure the desired result. */ + Don't lie, but adjust ids as necessary to secure the desired + result. */ if (cred == (struct iouser *) -1) { @@ -548,7 +579,8 @@ nfs_initialize_rpc (int rpc_proc, struct iouser *cred, uid, gid, second_gid); } -/* ERROR is an NFS error code; return the correspending Hurd error. */ +/* ERROR is an NFS error code; return the correspending Hurd + error. */ error_t nfs_error_trans (int error) { @@ -639,7 +671,7 @@ nfs_error_trans (int error) case NFSERR_BAD_COOKIE: case NFSERR_TOOSMALL: case NFSERR_JUKEBOX: /* ??? */ - /* These indicate bugs in the client, so EGRATUITOUS is right. */ + /* These indicate bugs in the client, so EGRATUITOUS is right. */ return EGRATUITOUS; } } diff --git a/nfs/ops.c b/nfs/ops.c index e36c6dc0..96190d2e 100644 --- a/nfs/ops.c +++ b/nfs/ops.c @@ -1,4 +1,4 @@ -/* Libnetfs callbacks for node operations in NFS client +/* ops.c - Libnetfs callbacks for node operations in NFS client. Copyright (C) 1994,95,96,97,99,2002 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or @@ -91,7 +91,8 @@ process_returned_stat (struct node *np, int *p, int mod) { int attrs_exist; - attrs_exist = ntohl (*p++); + attrs_exist = ntohl (*p); + p++; if (attrs_exist) p = register_fresh_stat (np, p); else if (mod) @@ -106,7 +107,7 @@ process_returned_stat (struct node *np, int *p, int mod) version 2, this is just register_fresh_stat. In version 3, it does the wcc_data interpretation too. If this follows an operation that we expect has modified the attributes, MOD should be set. - (This unpacks the wcc_data XDR type.) */ + (This unpacks the wcc_data XDR type.) */ int * process_wcc_stat (struct node *np, int *p, int mod) { @@ -117,7 +118,8 @@ process_wcc_stat (struct node *np, int *p, int mod) int attrs_exist; /* First the pre_op_attr */ - attrs_exist = ntohl (*p++); + attrs_exist = ntohl (*p); + p++; if (attrs_exist) { /* Just skip them for now */ @@ -133,7 +135,7 @@ process_wcc_stat (struct node *np, int *p, int mod) /* Implement the netfs_validate_stat callback as described in - . */ + . */ error_t netfs_validate_stat (struct node *np, struct iouser *cred) { @@ -153,7 +155,10 @@ netfs_validate_stat (struct node *np, struct iouser *cred) err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } if (!err) register_fresh_stat (np, p); @@ -162,7 +167,7 @@ netfs_validate_stat (struct node *np, struct iouser *cred) } /* Implement the netfs_attempt_chown callback as described in - . */ + . */ error_t netfs_attempt_chown (struct iouser *cred, struct node *np, uid_t uid, gid_t gid) @@ -179,12 +184,13 @@ netfs_attempt_chown (struct iouser *cred, struct node *np, p = xdr_encode_fhandle (p, &np->nn->handle); p = xdr_encode_sattr_ids (p, uid, gid); if (protocol_version == 3) - *p++ = 0; /* guard_check == 0 */ + *(p++) = 0; /* guard_check == 0 */ err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (!err || protocol_version == 3) p = process_wcc_stat (np, p, !err); } @@ -204,7 +210,7 @@ netfs_attempt_chauthor (struct iouser *cred, struct node *rp, } /* Implement the netfs_attempt_chmod callback as described in - . */ + . */ error_t netfs_attempt_chmod (struct iouser *cred, struct node *np, mode_t mode) @@ -219,7 +225,8 @@ netfs_attempt_chmod (struct iouser *cred, struct node *np, if (err) return err; - /* Has the file type changed? (e.g. from symlink to directory) */ + /* Has the file type changed? (e.g. from symlink to + directory). */ if ((mode & S_IFMT) != (np->nn_stat.st_mode & S_IFMT)) { char *f = 0; @@ -258,12 +265,13 @@ netfs_attempt_chmod (struct iouser *cred, struct node *np, p = xdr_encode_fhandle (p, &np->nn->handle); p = xdr_encode_sattr_mode (p, mode); if (protocol_version == 3) - *p++ = 0; /* guard check == 0 */ + *(p++) = 0; /* guard check == 0 */ err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (!err || protocol_version == 3) p = process_wcc_stat (np, p, !err); } @@ -273,7 +281,7 @@ netfs_attempt_chmod (struct iouser *cred, struct node *np, } /* Implement the netfs_attempt_chflags callback as described in - . */ + . */ error_t netfs_attempt_chflags (struct iouser *cred, struct node *np, int flags) @@ -312,12 +320,13 @@ netfs_attempt_utimes (struct iouser *cred, struct node *np, atime ?: ¤t, mtime ?: ¤t); if (protocol_version == 3) - *p++ = 0; /* guard check == 0 */ + *(p++) = 0; /* guard check == 0 */ err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (!err || protocol_version == 3) p = process_wcc_stat (np, p, !err); } @@ -327,7 +336,7 @@ netfs_attempt_utimes (struct iouser *cred, struct node *np, } /* Implement the netfs_attempt_set_size callback as described in - . */ + . */ error_t netfs_attempt_set_size (struct iouser *cred, struct node *np, off_t size) @@ -344,12 +353,13 @@ netfs_attempt_set_size (struct iouser *cred, struct node *np, p = xdr_encode_fhandle (p, &np->nn->handle); p = xdr_encode_sattr_size (p, size); if (protocol_version == 3) - *p++ = 0; /* guard_check == 0 */ + *(p++) = 0; /* guard_check == 0 */ err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (!err || protocol_version == 3) p = process_wcc_stat (np, p, !err); } @@ -390,15 +400,22 @@ netfs_attempt_statfs (struct iouser *cred, struct node *np, err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } if (!err) { p++; /* skip IOSIZE field */ - st->f_bsize = ntohl (*p++); - st->f_blocks = ntohl (*p++); - st->f_bfree = ntohl (*p++); - st->f_bavail = ntohl (*p++); + st->f_bsize = ntohl (*p); + p++; + st->f_blocks = ntohl (*p); + p++; + st->f_bfree = ntohl (*p); + p++; + st->f_bavail = ntohl (*p); + p++; st->f_type = FSTYPE_NFS; st->f_files = 0; st->f_ffree = 0; @@ -411,7 +428,7 @@ netfs_attempt_statfs (struct iouser *cred, struct node *np, } /* Implement the netfs_attempt_sync callback as described in - . */ + . */ error_t netfs_attempt_sync (struct iouser *cred, struct node *np, int wait) { @@ -428,7 +445,7 @@ netfs_attempt_syncfs (struct iouser *cred, int wait) } /* Implement the netfs_attempt_read callback as described in - . */ + . */ error_t netfs_attempt_read (struct iouser *cred, struct node *np, off_t offset, size_t *len, void *data) @@ -452,15 +469,16 @@ netfs_attempt_read (struct iouser *cred, struct node *np, return errno; p = xdr_encode_fhandle (p, &np->nn->handle); - *p++ = htonl (offset); - *p++ = htonl (thisamt); + *(p++) = htonl (offset); + *(p++) = htonl (thisamt); if (protocol_version == 2) - *p++ = 0; + *(p++) = 0; err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (!err || protocol_version == 3) p = process_returned_stat (np, p, !err); @@ -471,12 +489,16 @@ netfs_attempt_read (struct iouser *cred, struct node *np, return err; } - trans_len = ntohl (*p++); + trans_len = ntohl (*p); + p++; if (trans_len > thisamt) trans_len = thisamt; /* ??? */ if (protocol_version == 3) - eof = ntohl (*p++); + { + eof = ntohl (*p); + p++; + } else eof = (trans_len < thisamt); @@ -498,7 +520,7 @@ netfs_attempt_read (struct iouser *cred, struct node *np, } /* Implement the netfs_attempt_write callback as described in - . */ + . */ error_t netfs_attempt_write (struct iouser *cred, struct node *np, off_t offset, size_t *len, void *data) @@ -522,25 +544,27 @@ netfs_attempt_write (struct iouser *cred, struct node *np, p = xdr_encode_fhandle (p, &np->nn->handle); if (protocol_version == 2) - *p++ = 0; - *p++ = htonl (offset); + *(p++) = 0; + *(p++) = htonl (offset); if (protocol_version == 2) - *p++ = 0; + *(p++) = 0; if (protocol_version == 3) - *p++ = htonl (FILE_SYNC); + *(p++) = htonl (FILE_SYNC); p = xdr_encode_data (p, data, thisamt); err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (!err || protocol_version == 3) p = process_wcc_stat (np, p, !err); if (!err) { if (protocol_version == 3) { - count = ntohl (*p++); + count = ntohl (*p); + p++; p++; /* ignore COMMITTED */ /* ignore verf for now */ p += NFS3_WRITEVERFSIZE / sizeof (int); @@ -596,7 +620,10 @@ verify_nonexistent (struct iouser *cred, struct node *dir, err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } free (rpcbuf); @@ -607,7 +634,7 @@ verify_nonexistent (struct iouser *cred, struct node *dir, } /* Implement the netfs_attempt_lookup callback as described in - . */ + . */ error_t netfs_attempt_lookup (struct iouser *cred, struct node *np, char *name, struct node **newnp) @@ -649,7 +676,8 @@ netfs_attempt_lookup (struct iouser *cred, struct node *np, err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (!err) { p = xdr_decode_fhandle (p, newnp); @@ -680,7 +708,7 @@ netfs_attempt_lookup (struct iouser *cred, struct node *np, } /* Implement the netfs_attempt_mkdir callback as described in - . */ + . */ error_t netfs_attempt_mkdir (struct iouser *cred, struct node *np, char *name, mode_t mode) @@ -713,7 +741,10 @@ netfs_attempt_mkdir (struct iouser *cred, struct node *np, err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } if (!err) { @@ -735,7 +766,7 @@ netfs_attempt_mkdir (struct iouser *cred, struct node *np, } /* Implement the netfs_attempt_rmdir callback as described in - . */ + . */ error_t netfs_attempt_rmdir (struct iouser *cred, struct node *np, char *name) @@ -759,7 +790,8 @@ netfs_attempt_rmdir (struct iouser *cred, struct node *np, err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (protocol_version == 3) p = process_wcc_stat (np, p, !err); } @@ -769,7 +801,7 @@ netfs_attempt_rmdir (struct iouser *cred, struct node *np, } /* Implement the netfs_attempt_link callback as described in - . */ + . */ error_t netfs_attempt_link (struct iouser *cred, struct node *dir, struct node *np, char *name, int excl) @@ -819,7 +851,10 @@ netfs_attempt_link (struct iouser *cred, struct node *dir, err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } mutex_unlock (&dir->lock); free (rpcbuf); @@ -868,7 +903,8 @@ netfs_attempt_link (struct iouser *cred, struct node *dir, err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (protocol_version == 2 && !err) { @@ -890,7 +926,10 @@ netfs_attempt_link (struct iouser *cred, struct node *dir, err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } if (!err) { mutex_lock (&np->lock); @@ -966,7 +1005,10 @@ netfs_attempt_link (struct iouser *cred, struct node *dir, _lengthy_ (blocking) conduct_rpc? */ err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } if (!err) { @@ -999,12 +1041,12 @@ netfs_attempt_link (struct iouser *cred, struct node *dir, free (rpcbuf); return err; } - *p++ = htonl (hurd_mode_to_nfs_type (np->nn_stat.st_mode)); + *(p++) = htonl (hurd_mode_to_nfs_type (np->nn_stat.st_mode)); p = xdr_encode_sattr_stat (p, &np->nn_stat); if (np->nn->dtrans == BLKDEV || np->nn->dtrans == CHRDEV) { - *p++ = htonl (major (np->nn_stat.st_rdev)); - *p++ = htonl (minor (np->nn_stat.st_rdev)); + *(p++) = htonl (major (np->nn_stat.st_rdev)); + *(p++) = htonl (minor (np->nn_stat.st_rdev)); } mutex_unlock (&np->lock); @@ -1012,7 +1054,9 @@ netfs_attempt_link (struct iouser *cred, struct node *dir, err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; + if (!err) { mutex_lock (&np->lock); @@ -1058,7 +1102,7 @@ netfs_attempt_link (struct iouser *cred, struct node *dir, } /* Implement the netfs_attempt_mkfile callback as described in - . */ + . */ error_t netfs_attempt_mkfile (struct iouser *cred, struct node *dir, mode_t mode, struct node **newnp) @@ -1101,7 +1145,7 @@ netfs_attempt_mkfile (struct iouser *cred, struct node *dir, } /* Implement the netfs_attempt_create_file callback as described in - . */ + . */ error_t netfs_attempt_create_file (struct iouser *cred, struct node *np, char *name, mode_t mode, struct node **newnp) @@ -1147,9 +1191,9 @@ netfs_attempt_create_file (struct iouser *cred, struct node *np, /* We happen to know this is where the XID is. */ int verf = *(int *)rpcbuf; - *p++ = ntohl (EXCLUSIVE); + *(p++) = ntohl (EXCLUSIVE); /* 8 byte verf */ - *p++ = ntohl (verf); + *(p++) = ntohl (verf); p++; } else @@ -1161,7 +1205,8 @@ netfs_attempt_create_file (struct iouser *cred, struct node *np, if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (!err) { p = xdr_decode_fhandle (p, newnp); @@ -1192,7 +1237,7 @@ netfs_attempt_create_file (struct iouser *cred, struct node *np, } /* Implement the netfs_attempt_unlink callback as described in - . */ + . */ error_t netfs_attempt_unlink (struct iouser *cred, struct node *dir, char *name) @@ -1283,7 +1328,8 @@ netfs_attempt_unlink (struct iouser *cred, struct node *dir, err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (protocol_version == 3) p = process_wcc_stat (dir, p, !err); } @@ -1294,7 +1340,7 @@ netfs_attempt_unlink (struct iouser *cred, struct node *dir, } /* Implement the netfs_attempt_rename callback as described in - . */ + . */ error_t netfs_attempt_rename (struct iouser *cred, struct node *fromdir, char *fromname, struct node *todir, char *toname, @@ -1360,7 +1406,8 @@ netfs_attempt_rename (struct iouser *cred, struct node *fromdir, err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (protocol_version == 3) /* XXX Should we add `&& !err' ? */ { mutex_lock (&fromdir->lock); @@ -1374,7 +1421,7 @@ netfs_attempt_rename (struct iouser *cred, struct node *fromdir, } /* Implement the netfs_attempt_readlink callback as described in - . */ + . */ error_t netfs_attempt_readlink (struct iouser *cred, struct node *np, char *buf) @@ -1399,7 +1446,8 @@ netfs_attempt_readlink (struct iouser *cred, struct node *np, err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; if (protocol_version == 3) p = process_returned_stat (np, p, 0); if (!err) @@ -1411,7 +1459,7 @@ netfs_attempt_readlink (struct iouser *cred, struct node *np, } /* Implement the netfs_check_open_permissions callback as described in - . */ + . */ error_t netfs_check_open_permissions (struct iouser *cred, struct node *np, int flags, int newnode) @@ -1429,7 +1477,7 @@ netfs_check_open_permissions (struct iouser *cred, struct node *np, } /* Implement the netfs_report_access callback as described in - . */ + . */ error_t netfs_report_access (struct iouser *cred, struct node *np, @@ -1477,18 +1525,20 @@ netfs_report_access (struct iouser *cred, return errno; p = xdr_encode_fhandle (p, &np->nn->handle); - *p++ = htonl (ACCESS3_READ | write_check | execute_check); + *(p++) = htonl (ACCESS3_READ | write_check | execute_check); err = conduct_rpc (&rpcbuf, &p); if (!err) { - err = nfs_error_trans (ntohl (*p++)); + err = nfs_error_trans (ntohl (*p)); + p++; p = process_returned_stat (np, p, 0); /* XXX Should this be protected by the if (!err) ? */ if (!err) { - ret = ntohl (*p++); + ret = ntohl (*p); + p++; *types = ((ret & ACCESS3_READ ? O_READ : 0) | (ret & write_check ? O_WRITE : 0) | (ret & execute_check ? O_EXEC : 0)); @@ -1499,7 +1549,7 @@ netfs_report_access (struct iouser *cred, } /* These definitions have unfortunate side effects, don't use them, - clever though they are. */ + clever though they are. */ #if 0 /* Implement the netfs_check_open_permissions callback as described in . */ @@ -1577,11 +1627,14 @@ netfs_check_open_permissions (struct iouser *cred, struct node *np, return failure. Otherwise, succeed. */ p = nfs_initialize_rpc (NFSPROC_READDIR, cred, 0, &rpcbuf, np, -1); p = xdr_encode_fhandle (p, &np->nn->handle); - *p++ = 0; - *p++ = htonl (50); + *(p++) = 0; + *(p++) = htonl (50); err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } free (rpcbuf); if (err) @@ -1592,7 +1645,7 @@ netfs_check_open_permissions (struct iouser *cred, struct node *np, } /* Implement the netfs_report_access callback as described in - . */ + . */ void netfs_report_access (struct iouser *cred, struct node *np, @@ -1642,7 +1695,7 @@ netfs_report_access (struct iouser *cred, *BUFP to that buffer. *BUFP must be freed by the caller when no longer needed. If an error occurs, don't touch *BUFP and return the error code. Set BUFSIZEP to the amount of data used inside - *BUFP and TOTALENTRIES to the total number of entries copied. */ + *BUFP and TOTALENTRIES to the total number of entries copied. */ static error_t fetch_directory (struct iouser *cred, struct node *dir, void **bufp, size_t *bufsizep, int *totalentries) @@ -1681,18 +1734,22 @@ fetch_directory (struct iouser *cred, struct node *dir, } p = xdr_encode_fhandle (p, &dir->nn->handle); - *p++ = cookie; - *p++ = ntohl (read_size); + *(p++) = cookie; + *(p++) = ntohl (read_size); err = conduct_rpc (&rpcbuf, &p); if (!err) - err = nfs_error_trans (ntohl (*p++)); + { + err = nfs_error_trans (ntohl (*p)); + p++; + } if (err) { free (buf); return err; } - isnext = ntohl (*p++); + isnext = ntohl (*p); + p++; /* Now copy them one at a time. */ while (isnext) @@ -1701,8 +1758,10 @@ fetch_directory (struct iouser *cred, struct node *dir, int namlen; int reclen; - fileno = ntohl (*p++); - namlen = ntohl (*p++); + fileno = ntohl (*p); + p++; + namlen = ntohl (*p); + p++; /* There's a hidden +1 here for the null byte and -1 because d_name has a size of one already in the sizeof. */ @@ -1727,7 +1786,7 @@ fetch_directory (struct iouser *cred, struct node *dir, entry->d_reclen = reclen; entry->d_type = DT_UNKNOWN; entry->d_namlen = namlen; - bcopy (p, entry->d_name, namlen); + memcpy (entry->d_name, p, namlen); entry->d_name[namlen] = '\0'; p += INTSIZE (namlen); @@ -1735,11 +1794,13 @@ fetch_directory (struct iouser *cred, struct node *dir, ++*totalentries; - cookie = *p++; - isnext = ntohl (*p++); + cookie = *(p++); + isnext = ntohl (*p); + p++; } - eof = ntohl (*p++); + eof = ntohl (*p); + p++; free (rpcbuf); } @@ -1751,7 +1812,7 @@ fetch_directory (struct iouser *cred, struct node *dir, /* Implement the netfs_get_directs callback as described in - . */ + . */ error_t netfs_get_dirents (struct iouser *cred, struct node *np, int entry, int nentries, char **data, @@ -1821,7 +1882,7 @@ netfs_get_dirents (struct iouser *cred, struct node *np, /* Implement the netfs_set_translator callback as described in - . */ + . */ error_t netfs_set_translator (struct iouser *cred, struct node *np, @@ -1832,7 +1893,7 @@ netfs_set_translator (struct iouser *cred, } /* Implement the netfs_attempt_mksymlink callback as described in - . */ + . */ error_t netfs_attempt_mksymlink (struct iouser *cred, struct node *np, @@ -1852,7 +1913,7 @@ netfs_attempt_mksymlink (struct iouser *cred, } /* Implement the netfs_attempt_mkdev callback as described in - . */ + . */ error_t netfs_attempt_mkdev (struct iouser *cred, struct node *np, diff --git a/nfs/rpc.c b/nfs/rpc.c index 252acfa3..f5e19066 100644 --- a/nfs/rpc.c +++ b/nfs/rpc.c @@ -1,4 +1,4 @@ -/* SunRPC management for NFS client +/* rpc.c - SunRPC management for NFS client. Copyright (C) 1994, 1995, 1996, 1997, 2002 Free Software Foundation This program is free software; you can redistribute it and/or @@ -17,10 +17,10 @@ #include "nfs.h" -/* Needed in order to get the RPC header files to include correctly */ +/* Needed in order to get the RPC header files to include correctly. */ #undef TRUE #undef FALSE -#define malloc spoiufasdf /* Avoid bogus definition in rpc/types.h */ +#define malloc spoiufasdf /* Avoid bogus definition in rpc/types.h. */ #include #include @@ -28,7 +28,7 @@ #include #include -#undef malloc /* Get rid of the sun block */ +#undef malloc /* Get rid of the sun block. */ #include #include @@ -37,26 +37,26 @@ #include #include -/* One of these exists for each pending RPC. */ +/* One of these exists for each pending RPC. */ struct rpc_list { struct rpc_list *next, **prevp; void *reply; }; -/* A list of all pending RPCs. */ +/* A list of all pending RPCs. */ static struct rpc_list *outstanding_rpcs; /* Wake up this condition when an outstanding RPC has received a reply - or we should check for timeouts. */ + or we should check for timeouts. */ static struct condition rpc_wakeup = CONDITION_INITIALIZER; -/* Lock the global data and the REPLY fields of outstanding RPC's. */ +/* Lock the global data and the REPLY fields of outstanding RPC's. */ static struct mutex outstanding_lock = MUTEX_INITIALIZER; -/* Generate and return a new transaction ID. */ +/* Generate and return a new transaction ID. */ static inline int generate_xid () { @@ -76,7 +76,7 @@ generate_xid () may be -1 to indicate that it does not apply, however, exactly zero or two of UID and GID must be -1. The returned address is a pointer to the start of the payload. If NULL is returned, an error occured - and the code is set in errno. */ + and the code is set in errno. */ int * initialize_rpc (int program, int version, int rpc_proc, size_t len, void **bufp, @@ -100,52 +100,52 @@ initialize_rpc (int program, int version, int rpc_proc, p = buf + sizeof (struct rpc_list); /* RPC header */ - *p++ = htonl (generate_xid ()); - *p++ = htonl (CALL); - *p++ = htonl (RPC_MSG_VERSION); - *p++ = htonl (program); - *p++ = htonl (version); - *p++ = htonl (rpc_proc); + *(p++) = htonl (generate_xid ()); + *(p++) = htonl (CALL); + *(p++) = htonl (RPC_MSG_VERSION); + *(p++) = htonl (program); + *(p++) = htonl (version); + *(p++) = htonl (rpc_proc); assert ((uid == -1) == (gid == -1)); if (uid == -1) { /* No authentication */ - *p++ = htonl (AUTH_NONE); - *p++ = 0; + *(p++) = htonl (AUTH_NONE); + *(p++) = 0; } else { /* Unixy authentication */ - *p++ = htonl (AUTH_UNIX); + *(p++) = htonl (AUTH_UNIX); /* The length of the message. We do not yet know what this is, so, just remember where we should put it when we know */ lenaddr = p++; - *p++ = htonl (mapped_time->seconds); + *(p++) = htonl (mapped_time->seconds); p = xdr_encode_string (p, hostname); - *p++ = htonl (uid); - *p++ = htonl (gid); + *(p++) = htonl (uid); + *(p++) = htonl (gid); if (second_gid == -1) - *p++ = 0; + *(p++) = 0; else { - *p++ = htonl (1); - *p++ = htonl (second_gid); + *(p++) = htonl (1); + *(p++) = htonl (second_gid); } *lenaddr = htonl ((p - (lenaddr + 1)) * sizeof (int)); } /* VERF field */ - *p++ = htonl (AUTH_NONE); - *p++ = 0; + *(p++) = htonl (AUTH_NONE); + *(p++) = 0; *bufp = buf; return p; } /* Remove HDR from the list of pending RPC's. The rpc_list's lock - (OUTSTANDING_LOCK) must be held */ + (OUTSTANDING_LOCK) must be held. */ static inline void unlink_rpc (struct rpc_list *hdr) { @@ -155,7 +155,7 @@ unlink_rpc (struct rpc_list *hdr) } /* Insert HDR at the head of the LIST. The rpc_list's lock - (OUTSTANDING_LOCK) must be held */ + (OUTSTANDING_LOCK) must be held. */ static inline void link_rpc (struct rpc_list **list, struct rpc_list *hdr) { @@ -171,7 +171,7 @@ link_rpc (struct rpc_list **list, struct rpc_list *hdr) the filledin args. Set *PP to the address of the reply contents themselves. The user will be expected to free *RPCBUF (which will have changed) when done with the reply contents. The old value of - *RPCBUF will be freed by this routine. */ + *RPCBUF will be freed by this routine. */ error_t conduct_rpc (void **rpcbuf, int **pp) { @@ -194,7 +194,7 @@ conduct_rpc (void **rpcbuf, int **pp) do { - /* If we've sent enough, give up */ + /* If we've sent enough, give up. */ if (mounted_soft && ntransmit == soft_retries) { unlink_rpc (hdr); @@ -202,7 +202,7 @@ conduct_rpc (void **rpcbuf, int **pp) return ETIMEDOUT; } - /* Issue the RPC */ + /* Issue the RPC. */ lasttrans = mapped_time->seconds; ntransmit++; nc = (void *) *pp - *rpcbuf - sizeof (struct rpc_list); @@ -216,7 +216,7 @@ conduct_rpc (void **rpcbuf, int **pp) else assert (cc == nc); - /* Wait for reply */ + /* Wait for reply. */ cancel = 0; while (!hdr->reply && (mapped_time->seconds - lasttrans < timeout) @@ -232,7 +232,7 @@ conduct_rpc (void **rpcbuf, int **pp) /* hdr->reply will have been filled in by rpc_receive_thread, if it has been filled in, then the rpc has been fulfilled, - otherwise, retransmit and continue to wait */ + otherwise, retransmit and continue to wait. */ if (!hdr->reply) { timeout *= 2; @@ -244,34 +244,36 @@ conduct_rpc (void **rpcbuf, int **pp) mutex_unlock (&outstanding_lock); - /* Switch to the reply buffer. */ + /* Switch to the reply buffer. */ *rpcbuf = hdr->reply; free (hdr); /* Process the reply, dissecting errors. When we're done and if - there is no error, set *PP to the rpc return contents */ + there is no error, set *PP to the rpc return contents. */ p = (int *) *rpcbuf; /* If the transmition id does not match that in the message, - something strange happened in rpc_receive_thread */ + something strange happened in rpc_receive_thread. */ assert (*p == xid); p++; - switch (ntohl (*p++)) + switch (ntohl (*p)) { default: err = EBADRPC; break; case REPLY: - switch (ntohl (*p++)) + p++; + switch (ntohl (*p)) { default: err = EBADRPC; break; case MSG_DENIED: - switch (ntohl (*p++)) + p++; + switch (ntohl (*p)) { default: err = EBADRPC; @@ -282,7 +284,8 @@ conduct_rpc (void **rpcbuf, int **pp) break; case AUTH_ERROR: - switch (ntohl (*p++)) + p++; + switch (ntohl (*p)) { case AUTH_BADCRED: case AUTH_REJECTEDCRED: @@ -304,13 +307,15 @@ conduct_rpc (void **rpcbuf, int **pp) break; case MSG_ACCEPTED: + p++; - /* Process VERF field. */ - p++; /* skip verf type */ - n = ntohl (*p++); /* size of verf */ - p += INTSIZE (n); /* skip verf itself */ + /* Process VERF field. */ + p++; /* Skip verf type. */ + n = ntohl (*p); /* Size of verf. */ + p++; + p += INTSIZE (n); /* Skip verf itself. */ - switch (ntohl (*p++)) + switch (ntohl (*p)) { default: case GARBAGE_ARGS: @@ -330,6 +335,7 @@ conduct_rpc (void **rpcbuf, int **pp) break; case SUCCESS: + p++; *pp = p; err = 0; break; @@ -342,7 +348,7 @@ conduct_rpc (void **rpcbuf, int **pp) } /* Dedicated thread to signal those waiting on rpc_wakeup - once a second. */ + once a second. */ void timeout_service_thread () { @@ -356,13 +362,13 @@ timeout_service_thread () } /* Dedicate thread to receive RPC replies, register them on the queue - of pending wakeups, and deal appropriately. */ + of pending wakeups, and deal appropriately. */ void rpc_receive_thread () { void *buf; - /* Allocate a receive buffer */ + /* Allocate a receive buffer. */ buf = malloc (1024 + read_size); assert (buf); @@ -381,7 +387,7 @@ rpc_receive_thread () mutex_lock (&outstanding_lock); - /* Find the rpc that we just fulfilled */ + /* Find the rpc that we just fulfilled. */ for (r = outstanding_rpcs; r; r = r->next) { if (* (int *) &r[1] == xid) @@ -399,8 +405,8 @@ rpc_receive_thread () mutex_unlock (&outstanding_lock); /* If r is not null then we had a message from a pending - (i.e. known) rpc. Thus, it was fulfilled and if we - want to get another request, a new buffer is needed */ + (i.e. known) rpc. Thus, it was fulfilled and if we want + to get another request, a new buffer is needed. */ if (r) { buf = malloc (1024 + read_size); -- cgit v1.2.3