api: cleanup headers

fix inconsistent use in headers of:
  struct glfs and glfs_t
  struct glfs_fd and glfs_fd_t
  struct glfs_object and glfs_object_t

add typedefs to headers for various struct glfs_foos, and use them, e.g.:
  struct glfs_upcall and glfs_upcall_t

fix inconsistent type naming for 'enum glfs_lock_mode_t'. (All other
enum decls are 'enum glfs_foo' not 'enum_glfs_foo_t'), and add
typedefs for all enums, and use them.

style, replace tabs with spaces and follow return value style, i.e.:
  int
  pub_glfs_foo()
instead of:
  int pub_glfs_foo()

Update copyright dates, substantial new work has been done since 2012

Change-Id: I0a9654486ea132efde7977b655799fb37887b1d5
Updates: bz#1193929
Signed-off-by: Kaleb S. KEITHLEY <kkeithle@redhat.com>

1 files changed, 91 insertions, 83 deletions

diff --git a/api/src/glfs-handles.h b/api/src/glfs-handles.h
index 42f46b0aaac..a5c6ff37043 100644
--- a/api/src/glfs-handles.h
+++ b/api/src/glfs-handles.h
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2013 Red Hat, Inc. <http://www.redhat.com>
+  Copyright (c) 2013-2018 Red Hat, Inc. <http://www.redhat.com>
   This file is part of GlusterFS.
 
   This file is licensed to you under your choice of the GNU Lesser
@@ -111,151 +111,159 @@ typedef struct glfs_object glfs_object_t;
  * to glfs_free().
  */
 struct glfs_upcall_inode;
+typedef struct glfs_upcall_inode glfs_upcall_inode_t;
 
-struct glfs_object*
-glfs_upcall_inode_get_object (struct glfs_upcall_inode *arg) __THROW
+glfs_object_t*
+glfs_upcall_inode_get_object (glfs_upcall_inode_t *arg) __THROW
         GFAPI_PUBLIC(glfs_upcall_inode_get_object, 3.7.16);
 
 uint64_t
-glfs_upcall_inode_get_flags (struct glfs_upcall_inode *arg) __THROW
+glfs_upcall_inode_get_flags (glfs_upcall_inode_t *arg) __THROW
         GFAPI_PUBLIC(glfs_upcall_inode_get_flags, 3.7.16);
 
 struct stat*
-glfs_upcall_inode_get_stat (struct glfs_upcall_inode *arg) __THROW
+glfs_upcall_inode_get_stat (glfs_upcall_inode_t *arg) __THROW
         GFAPI_PUBLIC(glfs_upcall_inode_get_stat, 3.7.16);
 
 uint64_t
-glfs_upcall_inode_get_expire (struct glfs_upcall_inode *arg) __THROW
+glfs_upcall_inode_get_expire (glfs_upcall_inode_t *arg) __THROW
         GFAPI_PUBLIC(glfs_upcall_inode_get_expire, 3.7.16);
 
-struct glfs_object*
-glfs_upcall_inode_get_pobject (struct glfs_upcall_inode *arg) __THROW
+glfs_object_t*
+glfs_upcall_inode_get_pobject (glfs_upcall_inode_t *arg) __THROW
         GFAPI_PUBLIC(glfs_upcall_inode_get_pobject, 3.7.16);
 
 struct stat*
-glfs_upcall_inode_get_pstat (struct glfs_upcall_inode *arg) __THROW
+glfs_upcall_inode_get_pstat (glfs_upcall_inode_t *arg) __THROW
         GFAPI_PUBLIC(glfs_upcall_inode_get_pstat, 3.7.16);
 
-struct glfs_object*
-glfs_upcall_inode_get_oldpobject (struct glfs_upcall_inode *arg) __THROW
+glfs_object_t*
+glfs_upcall_inode_get_oldpobject (glfs_upcall_inode_t *arg) __THROW
         GFAPI_PUBLIC(glfs_upcall_inode_get_oldpobject, 3.7.16);
 
 struct stat*
-glfs_upcall_inode_get_oldpstat (struct glfs_upcall_inode *arg) __THROW
+glfs_upcall_inode_get_oldpstat (glfs_upcall_inode_t *arg) __THROW
         GFAPI_PUBLIC(glfs_upcall_inode_get_oldpstat, 3.7.16);
 
 
 /* Handle based operations */
 /* Operations that generate handles */
-struct glfs_object *glfs_h_lookupat (struct glfs *fs,
-                                     struct glfs_object *parent,
-                                     const char *path,
-                                     struct stat *stat, int follow) __THROW
+glfs_object_t*
+glfs_h_lookupat (glfs_t *fs, glfs_object_t *parent, const char *path,
+                 struct stat *stat, int follow) __THROW
         GFAPI_PUBLIC(glfs_h_lookupat, 3.7.4);
 
-struct glfs_object *glfs_h_creat (struct glfs *fs, struct glfs_object *parent,
-				  const char *path, int flags, mode_t mode,
-				  struct stat *sb) __THROW
+glfs_object_t*
+glfs_h_creat (glfs_t *fs, glfs_object_t *parent, const char *path,
+              int flags, mode_t mode, struct stat *sb) __THROW
         GFAPI_PUBLIC(glfs_h_creat, 3.4.2);
 
-struct glfs_object *glfs_h_mkdir (struct glfs *fs, struct glfs_object *parent,
-				  const char *path, mode_t flags,
-				  struct stat *sb) __THROW
+glfs_object_t*
+glfs_h_mkdir (glfs_t *fs, glfs_object_t *parent, const char *path,
+              mode_t flags, struct stat *sb) __THROW
         GFAPI_PUBLIC(glfs_h_mkdir, 3.4.2);
 
-struct glfs_object *glfs_h_mknod (struct glfs *fs, struct glfs_object *parent,
-				  const char *path, mode_t mode, dev_t dev,
-				  struct stat *sb) __THROW
+glfs_object_t*
+glfs_h_mknod (glfs_t *fs, glfs_object_t *parent, const char *path,
+              mode_t mode, dev_t dev, struct stat *sb) __THROW
         GFAPI_PUBLIC(glfs_h_mknod, 3.4.2);
 
-struct glfs_object *glfs_h_symlink (struct glfs *fs, struct glfs_object *parent,
-				    const char *name, const char *data,
-				    struct stat *stat) __THROW
+glfs_object_t*
+glfs_h_symlink (glfs_t *fs, glfs_object_t *parent, const char *name,
+                const char *data, struct stat *stat) __THROW
         GFAPI_PUBLIC(glfs_h_symlink, 3.4.2);
 
 /* Operations on the actual objects */
-int glfs_h_unlink (struct glfs *fs, struct glfs_object *parent,
-		   const char *path) __THROW
+int
+glfs_h_unlink (glfs_t *fs, glfs_object_t *parent, const char *path) __THROW
         GFAPI_PUBLIC(glfs_h_unlink, 3.4.2);
 
-int glfs_h_close (struct glfs_object *object) __THROW
+int
+glfs_h_close (glfs_object_t *object) __THROW
         GFAPI_PUBLIC(glfs_h_close, 3.4.2);
 
-int glfs_caller_specific_init (void *uid_caller_key, void *gid_caller_key,
-			       void *future) __THROW
+int
+glfs_caller_specific_init (void *uid_caller_key, void *gid_caller_key,
+                           void *future) __THROW
         GFAPI_PUBLIC(glfs_caller_specific_init, 3.5.0);
 
-int glfs_h_truncate (struct glfs *fs, struct glfs_object *object,
-                     off_t offset) __THROW
+int
+glfs_h_truncate (glfs_t *fs, glfs_object_t *object,
+                 off_t offset) __THROW
         GFAPI_PUBLIC(glfs_h_truncate, 3.4.2);
 
-int glfs_h_stat(struct glfs *fs, struct glfs_object *object,
-                struct stat *stat) __THROW
+int
+glfs_h_stat(glfs_t *fs, glfs_object_t *object, struct stat *stat) __THROW
         GFAPI_PUBLIC(glfs_h_stat, 3.4.2);
 
-int glfs_h_statfs(struct glfs *fs, struct glfs_object *object,
-                struct statvfs *stat) __THROW
+int
+glfs_h_statfs(glfs_t *fs, glfs_object_t *object, struct statvfs *stat) __THROW
         GFAPI_PUBLIC(glfs_h_statfs, 3.7.0);
 
-int glfs_h_getattrs (struct glfs *fs, struct glfs_object *object,
-		     struct stat *stat) __THROW
+int
+glfs_h_getattrs (glfs_t *fs, glfs_object_t *object, struct stat *stat) __THROW
         GFAPI_PUBLIC(glfs_h_getattrs, 3.4.2);
 
-int glfs_h_getxattrs (struct glfs *fs, struct glfs_object *object,
-		      const char *name, void *value,
-		      size_t size) __THROW
+int
+glfs_h_getxattrs (glfs_t *fs, glfs_object_t *object, const char *name,
+                  void *value, size_t size) __THROW
         GFAPI_PUBLIC(glfs_h_getxattrs, 3.5.1);
 
-int glfs_h_setattrs (struct glfs *fs, struct glfs_object *object,
-		     struct stat *sb, int valid) __THROW
+int
+glfs_h_setattrs (glfs_t *fs, glfs_object_t *object, struct stat *sb,
+                 int valid) __THROW
         GFAPI_PUBLIC(glfs_h_setattrs, 3.4.2);
 
-int glfs_h_setxattrs (struct glfs *fs, struct glfs_object *object,
-		      const char *name, const void *value,
-		      size_t size, int flags) __THROW
+int
+glfs_h_setxattrs (glfs_t *fs, glfs_object_t *object, const char *name,
+                  const void *value, size_t size, int flags) __THROW
         GFAPI_PUBLIC(glfs_h_setxattrs, 3.5.0);
 
-int glfs_h_readlink (struct glfs *fs, struct glfs_object *object, char *buf,
-		     size_t bufsiz) __THROW
+int
+glfs_h_readlink (glfs_t *fs, glfs_object_t *object, char *buf,
+                 size_t bufsiz) __THROW
         GFAPI_PUBLIC(glfs_h_readlink, 3.4.2);
 
-int glfs_h_link (struct glfs *fs, struct glfs_object *linktgt,
-		 struct glfs_object *parent, const char *name) __THROW
+int
+glfs_h_link (glfs_t *fs, glfs_object_t *linktgt, glfs_object_t *parent,
+             const char *name) __THROW
         GFAPI_PUBLIC(glfs_h_link, 3.4.2);
 
-int glfs_h_rename (struct glfs *fs, struct glfs_object *olddir,
-		   const char *oldname, struct glfs_object *newdir,
-		   const char *newname) __THROW
+int
+glfs_h_rename (glfs_t *fs, glfs_object_t *olddir, const char *oldname,
+               glfs_object_t *newdir, const char *newname) __THROW
         GFAPI_PUBLIC(glfs_h_rename, 3.4.2);
 
-int glfs_h_removexattrs (struct glfs *fs, struct glfs_object *object,
-			 const char *name) __THROW
+int
+glfs_h_removexattrs (glfs_t *fs, glfs_object_t *object,
+                     const char *name) __THROW
         GFAPI_PUBLIC(glfs_h_removexattrs, 3.5.1);
 
 /* Operations enabling opaque invariant handle to object transitions */
-ssize_t glfs_h_extract_handle (struct glfs_object *object,
-			       unsigned char *handle, int len) __THROW
+ssize_t
+glfs_h_extract_handle (glfs_object_t *object, unsigned char *handle,
+                       int len) __THROW
         GFAPI_PUBLIC(glfs_h_extract_handle, 3.4.2);
 
 /* Given a handle, looks up the inode and creates glfs_object.
  * In addition, if provided 'stat', copies the inode attributes
  */
-struct glfs_object *glfs_h_create_from_handle (struct glfs *fs,
-					       unsigned char *handle, int len,
-					       struct stat *stat) __THROW
+glfs_object_t*
+glfs_h_create_from_handle (glfs_t *fs, unsigned char *handle, int len,
+                           struct stat *stat) __THROW
         GFAPI_PUBLIC(glfs_h_create_from_handle, 3.4.2);
 
 /* Operations enabling object handles to fd transitions */
-struct glfs_fd *glfs_h_opendir (struct glfs *fs,
-                                struct glfs_object *object) __THROW
+glfs_fd_t*
+glfs_h_opendir (glfs_t *fs, glfs_object_t *object) __THROW
         GFAPI_PUBLIC(glfs_h_opendir, 3.4.2);
 
-struct glfs_fd *glfs_h_open (struct glfs *fs, struct glfs_object *object,
-			     int flags) __THROW
+glfs_fd_t*
+glfs_h_open (glfs_t *fs, glfs_object_t *object, int flags) __THROW
         GFAPI_PUBLIC(glfs_h_open, 3.4.2);
 
 int
-glfs_h_access (struct glfs *fs, struct glfs_object *object, int mask) __THROW
+glfs_h_access (glfs_t *fs, glfs_object_t *object, int mask) __THROW
         GFAPI_PUBLIC(glfs_h_access, 3.6.0);
 
 /*
@@ -289,27 +297,27 @@ glfs_h_access (struct glfs *fs, struct glfs_object *object, int mask) __THROW
 */
 
 int
-glfs_h_poll_upcall (struct glfs *fs, struct glfs_upcall **cbk) __THROW
+glfs_h_poll_upcall (glfs_t *fs, glfs_upcall_t **cbk) __THROW
         GFAPI_PUBLIC(glfs_h_poll_upcall, 3.7.16);
 
 int
-glfs_h_acl_set (struct glfs *fs, struct glfs_object *object,
-                const acl_type_t type, const acl_t acl) __THROW
+glfs_h_acl_set (glfs_t *fs, glfs_object_t *object, const acl_type_t type,
+                const acl_t acl) __THROW
         GFAPI_PUBLIC(glfs_h_acl_set, 3.7.0);
 
 acl_t
-glfs_h_acl_get (struct glfs *fs, struct glfs_object *object,
+glfs_h_acl_get (glfs_t *fs, glfs_object_t *object,
                 const acl_type_t type) __THROW
         GFAPI_PUBLIC(glfs_h_acl_get, 3.7.0);
 
 size_t
-glfs_h_anonymous_write (struct glfs *fs, struct glfs_object *object,
-                        const void *buf, size_t count, off_t offset) __THROW
+glfs_h_anonymous_write (glfs_t *fs, glfs_object_t *object, const void *buf,
+                        size_t count, off_t offset) __THROW
         GFAPI_PUBLIC(glfs_h_anonymous_write, 3.7.0);
 
 ssize_t
-glfs_h_anonymous_read (struct glfs *fs, struct glfs_object *object,
-                      const void *buf, size_t count, off_t offset) __THROW
+glfs_h_anonymous_read (glfs_t *fs, glfs_object_t *object,
+                       const void *buf, size_t count, off_t offset) __THROW
         GFAPI_PUBLIC(glfs_h_anonymous_read, 3.7.0);
 
 /*
@@ -317,23 +325,23 @@ glfs_h_anonymous_read (struct glfs *fs, struct glfs_object *object,
  * of 'glfs_free(xstat)'. Make sure to have a copy using 'glfs_object_copy()'
  * to use post that.
  */
-struct glfs_object*
+glfs_object_t*
 glfs_xreaddirplus_get_object (struct glfs_xreaddirp_stat *xstat) __THROW
         GFAPI_PUBLIC(glfs_xreaddirplus_get_object, 3.11.0);
 
 /* Applications should close the object returned by this routine
  * explicitly using 'glfs_h_close()'
  */
-struct glfs_object*
-glfs_object_copy (struct glfs_object *src) __THROW
+glfs_object_t*
+glfs_object_copy (glfs_object_t *src) __THROW
         GFAPI_PUBLIC(glfs_object_copy, 3.11.0);
 
-int glfs_h_lease (struct glfs *fs, struct glfs_object *object,
-                  struct glfs_lease *lease) __THROW
+int
+glfs_h_lease (glfs_t *fs, glfs_object_t *object, glfs_lease_t *lease) __THROW
         GFAPI_PUBLIC(glfs_h_lease, 4.0.0);
 
-struct glfs_object *
-glfs_h_find_handle (struct glfs *fs, unsigned char *handle,
+glfs_object_t*
+glfs_h_find_handle (glfs_t *fs, unsigned char *handle,
                     int len) __THROW
         GFAPI_PUBLIC(glfs_h_lease, 4.0.0);
 __END_DECLS