Remove () around return values

bin/discover.c

@@ -89,5 +89,5 @@ int main()
 
   netbios_ns_discover_stop(ns);
 
-  return (0);
+  return 0;
 }

bin/dsm.c

@@ -248,5 +248,5 @@ int main(int ac, char **av)
   smb_session_destroy(session);
   netbios_ns_destroy(ns);
 
-  return (0);
+  return 0;
 }

bin/inverse.c

@@ -63,5 +63,5 @@ int main(int ac, char **av)
 
   printf("%s\n", name);
   netbios_ns_destroy(ns);
-  return (0);
+  return 0;
 }

bin/lookup.c

@@ -64,5 +64,5 @@ int main(int ac, char **av)
 
   printf("%s's IP address is : %s\n", av[1], inet_ntoa(addr));
   netbios_ns_destroy(ns);
-  return (0);
+  return 0;
 }

compat/compat.c

@@ -4,5 +4,5 @@
    libcompat.a to be empty, which is illegal */
 int not_empty()
 {
-    return (42);
+    return 42;
 }

src/hmac_md5.c

@@ -85,5 +85,5 @@ unsigned char *HMAC_MD5(const void *key, size_t key_len, const void *msg,
     MD5_Update(&ctx, kcat, 80);
     MD5_Final(out, &ctx);
 
-    return (out);
+    return out;
 }

src/netbios_ns.c

@@ -139,11 +139,11 @@ static int    ns_open_socket(netbios_ns *ns)
     if (bind(ns->socket, (struct sockaddr *)&ns->addr, sizeof(ns->addr)) < 0)
         goto error;
 
-    return (1);
+    return 1;
 
 error:
     BDSM_perror("netbios_ns_new, open_socket: ");
-    return (0);
+    return 0;
 }
 
 static int    ns_open_abort_pipe(netbios_ns *ns)
@@ -423,12 +423,12 @@ static ssize_t netbios_ns_recv(netbios_ns *ns,
             return size;
         }
         else
-            return (0);
+            return 0;
     }
 
 error:
     BDSM_perror("netbios_ns_recv: ");
-    return (-1);
+    return -1;
 }
 
 static void netbios_ns_copy_name(char *dest, const char *src)
@@ -524,13 +524,13 @@ netbios_ns  *netbios_ns_new()
     if (!ns_open_socket(ns) || ns_open_abort_pipe(ns) == -1)
     {
         netbios_ns_destroy(ns);
-        return (0);
+        return 0;
     }
 
     TAILQ_INIT(&ns->entry_queue);
     ns->last_trn_id   = rand();
 
-    return (ns);
+    return ns;
 }
 
 void          netbios_ns_destroy(netbios_ns *ns)
@@ -560,18 +560,18 @@ int      netbios_ns_resolve(netbios_ns *ns, const char *name, char type, uint32_
     if ((cached = netbios_ns_entry_find(ns, name, 0)) != NULL)
     {
         *addr = cached->address.s_addr;
-        return (1);
+        return 1;
     }
 
     if ((encoded_name = netbios_name_encode(name, 0, type)) == NULL)
-        return (0);
+        return 0;
 
     if (netbios_ns_send_name_query(ns, 0, NAME_QUERY_TYPE_NB, encoded_name,
                                    NETBIOS_FLAG_RECURSIVE |
                                    NETBIOS_FLAG_BROADCAST) == -1)
     {
         free(encoded_name);
-        return (0);
+        return 0;
     }
     free(encoded_name);
 
@@ -588,12 +588,12 @@ int      netbios_ns_resolve(netbios_ns *ns, const char *name, char type, uint32_
         {
             *addr = name_query.u.nb.ip;
             BDSM_dbg("netbios_ns_resolve, received a reply for '%s', ip: 0x%X!\n", name, *addr);
-            return (1);
+            return 1;
         } else
             BDSM_dbg("netbios_ns_resolve, wrong query type received\n");
     }
 
-    return (0);
+    return 0;
 }
 
 static int    netbios_ns_is_aborted(netbios_ns *ns)
@@ -627,7 +627,7 @@ static netbios_ns_entry *netbios_ns_inverse_internal(netbios_ns *ns, uint32_t ip
     netbios_ns_entry *entry;
 
     if ((cached = netbios_ns_entry_find(ns, NULL, ip)) != NULL)
-        return (cached);
+        return cached;
 
     if (netbios_ns_send_name_query(ns, ip, NAME_QUERY_TYPE_NBSTAT,
                                    name_query_broadcast, 0) == -1)
@@ -658,7 +658,7 @@ static netbios_ns_entry *netbios_ns_inverse_internal(netbios_ns *ns, uint32_t ip
     return entry;
 error:
     BDSM_perror("netbios_ns_inverse: ");
-    return (NULL);
+    return NULL;
 }
 
 const char *netbios_ns_inverse(netbios_ns *ns, uint32_t ip)
@@ -807,16 +807,16 @@ int netbios_ns_discover_start(netbios_ns *ns,
                               netbios_ns_discover_callbacks *callbacks)
 {
     if (ns->discover_started || !callbacks)
-        return (0);
+        return 0;
 
     ns->discover_callbacks = *callbacks;
     ns->discover_broadcast_timeout = broadcast_timeout;
     if (pthread_create(&ns->discover_thread, NULL,
                        netbios_ns_discover_thread, ns) != 0)
-        return (0);
+        return 0;
     ns->discover_started = true;
 
-    return (1);
+    return 1;
 }
 
 int netbios_ns_discover_stop(netbios_ns *ns)
@@ -827,8 +827,8 @@ int netbios_ns_discover_stop(netbios_ns *ns)
         pthread_join(ns->discover_thread, NULL);
         ns->discover_started = false;
 
-        return (1);
+        return 1;
     }
     else
-        return (0);
+        return 0;
 }

src/netbios_query.c

@@ -56,7 +56,7 @@ netbios_query   *netbios_query_new(size_t payload_size,
     q->packet->flags  = htons(opcode << 11);
     netbios_query_set_flag(q, NETBIOS_FLAG_QUERY, !is_query);
 
-    return (q);
+    return q;
 }
 
 void              netbios_query_destroy(netbios_query *q)
@@ -108,9 +108,9 @@ int               netbios_query_append(netbios_query *q, const char *data,
     assert(q && q->packet);
 
     if (q->payload_size - q->cursor < data_size)
-        return (-1);
+        return -1;
 
     memcpy(((char *)&q->packet->payload) + q->cursor, data, data_size);
     q->cursor += data_size;
-    return (0);
+    return 0;
 }

src/netbios_session.c

@@ -49,11 +49,11 @@ static int        open_socket_and_connect(netbios_session *s)
     if (connect(s->socket, (struct sockaddr *)&s->remote_addr, sizeof(s->remote_addr)) <0)
         goto error;
 
-    return (1);
+    return 1;
 
 error:
     BDSM_perror("netbios_session_new, open_socket: ");
-    return (0);
+    return 0;
 }
 
 static int        session_buffer_realloc(netbios_session *s, size_t new_size)
@@ -70,10 +70,10 @@ static int        session_buffer_realloc(netbios_session *s, size_t new_size)
     {
         s->packet_payload_size = new_size;
         s->packet = new_ptr;
-        return (1);
+        return 1;
     } else
         free(s->packet);
-    return (0);
+    return 0;
 }
 
 netbios_session *netbios_session_new(size_t buf_size)
@@ -93,7 +93,7 @@ netbios_session *netbios_session_new(size_t buf_size)
         return NULL;
     }
 
-    return (session);
+    return session;
 }
 
 void              netbios_session_destroy(netbios_session *s)
@@ -150,17 +150,17 @@ int               netbios_session_connect(struct in_addr *addr,
         if (s->packet->opcode != NETBIOS_OP_SESSION_REQ_OK)
         {
             s->state = NETBIOS_SESSION_REFUSED;
-            return (0);
+            return 0;
         }
     }
 
     // Reply was OK or DirectTCP, a session has been established
     s->state = NETBIOS_SESSION_CONNECTED;
-    return (1);
+    return 1;
 
 error:
     s->state = NETBIOS_SESSION_ERROR;
-    return (0);
+    return 0;
 }
 
 void              netbios_session_packet_init(netbios_session *s)
@@ -187,7 +187,7 @@ int               netbios_session_packet_append(netbios_session *s,
     memcpy(start, data, size);
     s->packet_cursor += size;
 
-    return (1);
+    return 1;
 }
 
 int               netbios_session_packet_send(netbios_session *s)
@@ -204,10 +204,10 @@ int               netbios_session_packet_send(netbios_session *s)
     if (sent != to_send)
     {
         BDSM_perror("netbios_session_packet_send: Unable to send (full?) packet");
-        return (0);
+        return 0;
     }
 
-    return (sent);
+    return sent;
 }
 
 static ssize_t    netbios_session_get_next_packet(netbios_session *s)
@@ -223,13 +223,13 @@ static ssize_t    netbios_session_get_next_packet(netbios_session *s)
     if (res <= 0)
     {
         BDSM_perror("netbios_session_packet_recv: ");
-        return (-1);
+        return -1;
     }
     else if ((size_t)res != sizeof(netbios_session_packet))
     {
         BDSM_dbg("netbios_session_packet_recv: incorrect size for received packet: %ld bytes",
                  res);
-        return (-1);
+        return -1;
     }
 
     total  = ntohs(s->packet->length);
@@ -238,7 +238,7 @@ static ssize_t    netbios_session_get_next_packet(netbios_session *s)
 
     if (total + sizeof(netbios_session_packet) > s->packet_payload_size)
         if (!session_buffer_realloc(s, total + sizeof(netbios_session_packet)))
-            return (-1);
+            return -1;
 
     //BDSM_dbg("Total = %ld, sofar = %ld\n", total, sofar);
 
@@ -250,7 +250,7 @@ static ssize_t    netbios_session_get_next_packet(netbios_session *s)
         if (res <= 0)
         {
             BDSM_perror("netbios_session_packet_recv: ");
-            return (-1);
+            return -1;
         }
         sofar += res;
     }
@@ -259,10 +259,10 @@ static ssize_t    netbios_session_get_next_packet(netbios_session *s)
     {
         BDSM_dbg("netbios_session_packet_recv: Packet size mismatch (%ld/%ld)\n",
                  sofar, total);
-        return (-1);
+        return -1;
     }
 
-    return (sofar);
+    return sofar;
 }
 
 ssize_t           netbios_session_packet_recv(netbios_session *s, void **data)
@@ -278,5 +278,5 @@ ssize_t           netbios_session_packet_recv(netbios_session *s, void **data)
     if ((size >= 0) && (data != NULL))
         *data = (void *) s->packet->payload;
 
-    return (size);
+    return size;
 }

src/netbios_utils.c

@@ -100,18 +100,18 @@ char  *netbios_name_encode(const char *name, char *domain,
     char      *encoded_name;
 
     if (!name)
-        return (0);
+        return 0;
 
     encoded_name = malloc(encoded_size);
     if (!encoded_name)
-        return (0);
+        return 0;
     encoded_name[0] = 32; // length of the field;
     netbios_name_level1_encode(name, encoded_name + 1, type);
     encoded_name[33] = 0;
 
     //printf("Encoded name (l2): %s.\n", encoded_name);
 
-    return (encoded_name);
+    return encoded_name;
 }
 
 int             netbios_name_decode(const char *encoded_name,
@@ -122,17 +122,17 @@ int             netbios_name_decode(const char *encoded_name,
     size_t  encoded_length;
 
     if (!encoded_name || !name)
-        return (-1);
+        return -1;
 
     encoded_length =  strlen(encoded_name);
 
     // XXX Support domain name :p
     if (encoded_length != 33)
-        return (-1);
+        return -1;
 
     netbios_name_level1_decode(encoded_name + 1, name);
     name[33] = '\0';
-    return (32);
+    return 32;
 }
 
 

src/smb_buffer.c

@@ -52,9 +52,9 @@ int     smb_buffer_alloc(smb_buffer *buf, size_t size)
     buf->data = malloc(size);
     if (buf->data) {
         buf->size = size;
-        return (1);
+        return 1;
     } else
-        return (0);
+        return 0;
 }
 
 void    smb_buffer_free(smb_buffer *buf)

src/smb_dir.c

@@ -83,7 +83,7 @@ uint32_t  smb_directory_rm(smb_session *s, smb_tid tid, const char *path)
         return DSM_ERROR_INVALID_RCV_MESS;
 
     if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
-        return (resp_msg.packet->header.status);
+        return resp_msg.packet->header.status;
 
     resp = (smb_directory_rm_resp *)resp_msg.packet->payload;
     if ((resp->wct != 0) || (resp->bct != 0))
@@ -155,5 +155,5 @@ uint32_t  smb_directory_create(smb_session *s, smb_tid tid, const char *path)
     if (!smb_session_recv_msg(s, &resp_msg))
         return DSM_ERROR_INVALID_RCV_MESS;
 
-    return (resp_msg.packet->header.status);
+    return resp_msg.packet->header.status;
 }

src/smb_fd.c

@@ -63,7 +63,7 @@ smb_share *smb_session_share_get(smb_session *s, smb_tid tid)
     while (iter != NULL && iter->tid != tid)
         iter = iter->next;
 
-    return (iter);
+    return iter;
 }
 
 smb_share *smb_session_share_remove(smb_session *s, smb_tid tid)
@@ -78,11 +78,11 @@ smb_share *smb_session_share_remove(smb_session *s, smb_tid tid)
     iter = s->shares;
 
     if (iter == NULL)
-        return (NULL);
+        return NULL;
     if (iter->tid == tid)
     {
         s->shares = s->shares->next;
-        return (iter);
+        return iter;
     }
 
     while (iter->next != NULL && iter->next->tid != tid)
@@ -92,9 +92,9 @@ smb_share *smb_session_share_remove(smb_session *s, smb_tid tid)
     {
         keep = iter->next;
         iter->next = iter->next->next;
-        return (keep);
+        return keep;
     }
-    return (NULL);
+    return NULL;
 }
 
 void            smb_session_share_clear(smb_session *s)
@@ -134,7 +134,7 @@ int         smb_session_file_add(smb_session *s, smb_tid tid, smb_file *f)
         return -1;
 
     if ((share = smb_session_share_get(s, tid)) == NULL)
-        return (0);
+        return 0;
 
     if (share->files == NULL)
         share->files = f;
@@ -146,7 +146,7 @@ int         smb_session_file_add(smb_session *s, smb_tid tid, smb_file *f)
         iter->next = f;
     }
 
-    return (1);
+    return 1;
 }
 
 smb_file  *smb_session_file_get(smb_session *s, smb_fd fd)
@@ -157,13 +157,13 @@ smb_file  *smb_session_file_get(smb_session *s, smb_fd fd)
     assert(s != NULL && fd);
 
     if ((share = smb_session_share_get(s, SMB_FD_TID(fd))) == NULL)
-        return (NULL);
+        return NULL;
 
     iter = share->files;
     while (iter != NULL && iter->fid != SMB_FD_FID(fd))
         iter = iter->next;
 
-    return (iter);
+    return iter;
 }
 
 smb_file  *smb_session_file_remove(smb_session *s, smb_fd fd)
@@ -174,16 +174,16 @@ smb_file  *smb_session_file_remove(smb_session *s, smb_fd fd)
     assert(s != NULL && fd);
 
     if ((share = smb_session_share_get(s, SMB_FD_TID(fd))) == NULL)
-        return (NULL);
+        return NULL;
 
     iter = share->files;
 
     if (iter == NULL)
-        return (NULL);
+        return NULL;
     if (iter->fid == SMB_FD_FID(fd))
     {
         share->files = iter->next;
-        return (iter);
+        return iter;
     }
 
     while (iter->next != NULL && iter->next->fid != SMB_FD_TID(fd))
@@ -192,8 +192,8 @@ smb_file  *smb_session_file_remove(smb_session *s, smb_fd fd)
     {
         keep = iter->next;
         iter->next = iter->next->next;
-        return (keep);
+        return keep;
     }
     else
-        return (NULL);
+        return NULL;
 }

src/smb_file.c

@@ -53,16 +53,16 @@ smb_fd      smb_fopen(smb_session *s, smb_tid tid, const char *path,
 
     assert(s != NULL && path != NULL);
     if ((share = smb_session_share_get(s, tid)) == NULL)
-        return (0);
+        return 0;
 
     path_len = smb_to_utf16(path, strlen(path) + 1, &utf_path);
     if (path_len == 0)
-        return (0);
+        return 0;
 
     req_msg = smb_message_new(SMB_CMD_CREATE);
     if (!req_msg) {
         free(utf_path);
-        return (0);
+        return 0;
     }
 
     // Set SMB Headers
@@ -103,17 +103,17 @@ smb_fd      smb_fopen(smb_session *s, smb_tid tid, const char *path,
     res = smb_session_send_msg(s, req_msg);
     smb_message_destroy(req_msg);
     if (!res)
-        return (0);
+        return 0;
 
     if (!smb_session_recv_msg(s, &resp_msg))
-        return (0);
+        return 0;
     if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
-        return (0);
+        return 0;
 
     resp = (smb_create_resp *)resp_msg.packet->payload;
     file = calloc(1, sizeof(smb_file));
     if (!file)
-        return (0);
+        return 0;
 
     file->fid           = resp->fid;
     file->tid           = tid;
@@ -128,7 +128,7 @@ smb_fd      smb_fopen(smb_session *s, smb_tid tid, const char *path,
 
     smb_session_file_add(s, tid, file); // XXX Check return
 
-    return (SMB_FD(tid, file->fid));
+    return SMB_FD(tid, file->fid);
 }
 
 void        smb_fclose(smb_session *s, smb_fd fd)
@@ -182,13 +182,13 @@ ssize_t   smb_fread(smb_session *s, smb_fd fd, void *buf, size_t buf_size)
 
     assert(s != NULL && buf != NULL);
     if (!fd)
-      return (-1);
+      return -1;
     if ((file = smb_session_file_get(s, fd)) == NULL)
-        return (-1);
+        return -1;
 
     req_msg = smb_message_new(SMB_CMD_READ);
     if (!req_msg)
-        return (-1);
+        return -1;
     req_msg->packet->header.tid = (uint16_t)file->tid;
 
     max_read = 0xffff;
@@ -209,18 +209,18 @@ ssize_t   smb_fread(smb_session *s, smb_fd fd, void *buf, size_t buf_size)
     res = smb_session_send_msg(s, req_msg);
     smb_message_destroy(req_msg);
     if (!res)
-        return (-1);
+        return -1;
 
     if (!smb_session_recv_msg(s, &resp_msg))
-        return (-1);
+        return -1;
     if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
-        return (-1);
+        return -1;
 
     resp = (smb_read_resp *)resp_msg.packet->payload;
     memcpy(buf, (char *)resp_msg.packet + resp->data_offset, resp->data_len);
     smb_fseek(s, fd, resp->data_len, SEEK_CUR);
 
-    return (resp->data_len);
+    return resp->data_len;
 }
 
 ssize_t   smb_fwrite(smb_session *s, smb_fd fd, void *buf, size_t buf_size)
@@ -241,7 +241,7 @@ ssize_t   smb_fwrite(smb_session *s, smb_fd fd, void *buf, size_t buf_size)
 
     req_msg = smb_message_new(SMB_CMD_WRITE);
     if (!req_msg)
-        return (-1);
+        return -1;
     req_msg->packet->header.tid = (uint16_t)file->tid;
 
     // total size of SMB message shall not exceed maximum size of netbios data payload
@@ -277,7 +277,7 @@ ssize_t   smb_fwrite(smb_session *s, smb_fd fd, void *buf, size_t buf_size)
 
     smb_fseek(s, fd, resp->data_len, SEEK_CUR);
 
-    return (resp->data_len);
+    return resp->data_len;
 }
 
 ssize_t   smb_fseek(smb_session *s, smb_fd fd, ssize_t offset, int whence)
@@ -287,14 +287,14 @@ ssize_t   smb_fseek(smb_session *s, smb_fd fd, ssize_t offset, int whence)
     assert(s != NULL);
 
     if (!fd || (file = smb_session_file_get(s, fd)) == NULL)
-        return (0);
+        return 0;
 
     if (whence == SMB_SEEK_SET)
         file->offset = offset;
     else if (whence == SMB_SEEK_CUR)
         file->offset += offset;
 
-    return (file->offset);
+    return file->offset;
 }
 
 uint32_t  smb_file_rm(smb_session *s, smb_tid tid, const char *path)
@@ -320,7 +320,7 @@ uint32_t  smb_file_rm(smb_session *s, smb_tid tid, const char *path)
     if (!req_msg)
     {
         free(utf_pattern);
-        return (DSM_ERROR_INTERNAL);
+        return DSM_ERROR_INTERNAL;
     }
 
     req_msg->packet->header.tid = (uint16_t)tid;
@@ -343,7 +343,7 @@ uint32_t  smb_file_rm(smb_session *s, smb_tid tid, const char *path)
         return DSM_ERROR_INVALID_RCV_MESS;
 
     if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
-        return (resp_msg.packet->header.status);
+        return resp_msg.packet->header.status;
 
     resp = (smb_file_rm_resp *)resp_msg.packet->payload;
     if ((resp->wct != 0) || (resp->bct != 0))

src/smb_message.c

@@ -51,11 +51,11 @@ static int     smb_message_expand_payload(smb_message *msg, size_t cursor, size_
         size_t new_payload_size = msg->payload_size + nb_blocks * PAYLOAD_BLOCK_SIZE;
         void *new_packet = realloc(msg->packet, sizeof(smb_packet) + new_payload_size);
         if (!new_packet)
-            return (0);
+            return 0;
         msg->packet = new_packet;
         msg->payload_size = new_payload_size;
     }
-    return (1);
+    return 1;
 }
 
 smb_message   *smb_message_new(uint8_t cmd)
@@ -78,7 +78,7 @@ smb_message   *smb_message_new(uint8_t cmd)
     msg->packet->header.command   = cmd;
     msg->packet->header.pid       = getpid();
 
-    return (msg);
+    return msg;
 }
 
 // Duplicate a message while growing payload_size.
@@ -102,7 +102,7 @@ smb_message   *smb_message_grow(smb_message *msg, size_t size)
     memcpy((void *)copy->packet, (void *)msg->packet,
            msg->payload_size + sizeof(smb_packet));
 
-    return (copy);
+    return copy;
 }
 
 void            smb_message_destroy(smb_message *msg)
@@ -118,14 +118,14 @@ int             smb_message_append(smb_message *msg, const void *data,
     assert(msg != NULL && data != NULL);
 
     if (smb_message_expand_payload(msg, msg->cursor, data_size) == 0)
-        return (0);
+        return 0;
 
     memcpy(msg->packet->payload + msg->cursor, data, data_size);
     msg->cursor += data_size;
 
     //BDSM_dbg("Cursor is at %d (append)\n", msg->cursor);
 
-    return (1);
+    return 1;
 }
 
 int             smb_message_insert(smb_message *msg, size_t cursor,
@@ -134,11 +134,11 @@ int             smb_message_insert(smb_message *msg, size_t cursor,
     assert(msg != NULL && data != NULL);
 
     if (smb_message_expand_payload(msg, cursor, data_size) == 0)
-        return (0);
+        return 0;
 
     memcpy(msg->packet->payload + cursor, data, data_size);
 
-    return (1);
+    return 1;
 }
 
 int             smb_message_advance(smb_message *msg, size_t size)
@@ -146,32 +146,32 @@ int             smb_message_advance(smb_message *msg, size_t size)
     assert(msg != NULL);
 
     if (smb_message_expand_payload(msg, msg->cursor, size) == 0)
-        return (0);
+        return 0;
 
     msg->cursor += size;
 
     //BDSM_dbg("Cursor is at %d (advance)\n", msg->cursor);
-    return (1);
+    return 1;
 }
 
 int             smb_message_put8(smb_message *msg, uint8_t data)
 {
-    return (smb_message_append(msg, (void *)&data, 1));
+    return smb_message_append(msg, (void *)&data, 1);
 }
 
 int             smb_message_put16(smb_message *msg, uint16_t data)
 {
-    return (smb_message_append(msg, (void *)&data, 2));
+    return smb_message_append(msg, (void *)&data, 2);
 }
 
 int             smb_message_put32(smb_message *msg, uint32_t data)
 {
-    return (smb_message_append(msg, (void *)&data, 4));
+    return smb_message_append(msg, (void *)&data, 4);
 }
 
 int             smb_message_put64(smb_message *msg, uint64_t data)
 {
-    return (smb_message_append(msg, (void *)&data, 8));
+    return smb_message_append(msg, (void *)&data, 8);
 }
 
 size_t          smb_message_put_utf16(smb_message *msg, const char *str,
@@ -189,8 +189,8 @@ size_t          smb_message_put_utf16(smb_message *msg, const char *str,
     //         utf_str_len, msg->cursor);
 
     if (res)
-        return (utf_str_len);
-    return (0);
+        return utf_str_len;
+    return 0;
 }
 
 int             smb_message_put_uuid(smb_message *msg, uint32_t a, uint16_t b,
@@ -199,16 +199,16 @@ int             smb_message_put_uuid(smb_message *msg, uint32_t a, uint16_t b,
     assert(msg != NULL);
 
     if (!smb_message_put32(msg, a))
-        return (0);
+        return 0;
     if (!smb_message_put16(msg, b))
-        return (0);
+        return 0;
     if (!smb_message_put16(msg, c))
-        return (0);
+        return 0;
     for (int i = 0; i < 8; i++)
         if (!smb_message_put8(msg, d[i]))
-            return (0);
+            return 0;
 
-    return (1);
+    return 1;
 }
 
 void            smb_message_flag(smb_message *msg, uint32_t flag, int value)

src/smb_ntlm.c

@@ -156,7 +156,7 @@ uint8_t     *smb_ntlm2_response(smb_ntlmh hash_v2, uint64_t srv_challenge,
     memcpy(response, (void *)hmac, 16);
     memcpy(response + 16, blob->data, blob->size);
 
-    return (response);
+    return response;
 }
 
 uint8_t     *smb_lm2_response(smb_ntlmh hash_v2, uint64_t srv_challenge,
@@ -165,7 +165,7 @@ uint8_t     *smb_lm2_response(smb_ntlmh hash_v2, uint64_t srv_challenge,
     smb_buffer buf;
 
     smb_buffer_init(&buf, (void *)&user_challenge, 8);
-    return (smb_ntlm2_response(hash_v2, srv_challenge, &buf));
+    return smb_ntlm2_response(hash_v2, srv_challenge, &buf);
 }
 
 // static void   _wcamelcase(char *str)
@@ -239,7 +239,7 @@ uint8_t     *smb_lm2_response(smb_ntlmh hash_v2, uint64_t srv_challenge,
 //   free(whost);
 //   free(whost_camel);
 
-//   return (res_sz);
+//   return res_sz;
 // }
 
 size_t      smb_ntlm_make_blob(smb_ntlm_blob **out_blob, uint64_t ts,
@@ -251,7 +251,7 @@ size_t      smb_ntlm_make_blob(smb_ntlm_blob **out_blob, uint64_t ts,
 
     blob = malloc(target->size + sizeof(smb_ntlm_blob));
     if (!blob)
-        return (0);
+        return 0;
 
     memset((void *)blob, 0, sizeof(smb_ntlm_blob));
     blob->header    = 0x101;
@@ -261,7 +261,7 @@ size_t      smb_ntlm_make_blob(smb_ntlm_blob **out_blob, uint64_t ts,
     memcpy(blob->target, target->data, target->size);
 
     *out_blob = blob;
-    return (sizeof(smb_ntlm_blob) + target->size);
+    return sizeof(smb_ntlm_blob) + target->size;
 }
 
 void        smb_ntlm2_session_key(smb_ntlmh hash_v2, void *ntlm2,

src/smb_session.c

@@ -67,7 +67,7 @@ smb_session   *smb_session_new()
     // Until we know more, assume server supports everything.
     // s->c
 
-    return (s);
+    return s;
 }
 
 void            smb_session_destroy(smb_session *s)
@@ -99,9 +99,9 @@ void            smb_session_destroy(smb_session *s)
 int             smb_session_state(smb_session *s)
 {
     if (s != NULL)
-        return (s->state);
+        return s->state;
     else
-        return (SMB_STATE_ERROR);
+        return SMB_STATE_ERROR;
 }
 
 void            smb_session_set_creds(smb_session *s, const char *domain,
@@ -160,13 +160,13 @@ int             smb_session_connect(smb_session *s, const char *name,
     s->state = SMB_STATE_NETBIOS_OK;
 
     if (!smb_negotiate(s))
-        return (0);
+        return 0;
 
-    return (1);
+    return 1;
 
 error:
     s->state = SMB_STATE_ERROR;
-    return (0);
+    return 0;
 }
 
 static int        smb_negotiate(smb_session *s)
@@ -219,11 +219,11 @@ static int        smb_negotiate(smb_session *s)
     // Yeah !
     s->state              = SMB_STATE_DIALECT_OK;
 
-    return (1);
+    return 1;
 
 error:
     s->state = SMB_STATE_ERROR;
-    return (0);
+    return 0;
 }
 
 
@@ -239,7 +239,7 @@ static int        smb_session_login_ntlm(smb_session *s, const char *domain,
 
     msg = smb_message_new(SMB_CMD_SETUP);
     if (!msg)
-        return (0);
+        return 0;
 
     // this struct will be set at the end when we know the payload size
     SMB_MSG_ADVANCE_PKT(msg, smb_session_req);
@@ -280,21 +280,21 @@ static int        smb_session_login_ntlm(smb_session *s, const char *domain,
     {
         smb_message_destroy(msg);
         BDSM_dbg("Unable to send Session Setup AndX message\n");
-        return (0);
+        return 0;
     }
     smb_message_destroy(msg);
 
     if (smb_session_recv_msg(s, &answer) == 0)
     {
         BDSM_dbg("Unable to get Session Setup AndX reply\n");
-        return (0);
+        return 0;
     }
 
     smb_session_resp *r = (smb_session_resp *)answer.packet->payload;
     if (answer.packet->header.status != NT_STATUS_SUCCESS)
     {
         BDSM_dbg("Session Setup AndX : failure.\n");
-        return (0);
+        return 0;
     }
 
     if (r->action & 0x0001)
@@ -303,7 +303,7 @@ static int        smb_session_login_ntlm(smb_session *s, const char *domain,
     s->srv.uid  = answer.packet->header.uid;
     s->state    = SMB_STATE_SESSION_OK;
 
-    return (1);
+    return 1;
 }
 
 int             smb_session_login(smb_session *s)
@@ -313,7 +313,7 @@ int             smb_session_login(smb_session *s)
     if (s->creds.domain == NULL
         || s->creds.login == NULL
         || s->creds.password == NULL)
-      return (0);
+      return 0;
 
     if (smb_session_supports(s, SMB_SESSION_XSEC))
         return (smb_session_login_spnego(s, s->creds.domain, s->creds.login,
@@ -328,38 +328,38 @@ int             smb_session_is_guest(smb_session *s)
 {
     // Invalid session object
     if (s == NULL)
-        return (-1);
+        return -1;
 
     // We're not logged in yet.
     if (smb_session_state(s) != SMB_STATE_SESSION_OK)
-        return (-1);
+        return -1;
 
     // We're logged in as guest
     if (s->guest)
-        return (1);
+        return 1;
 
     // We're logged in as regular user
-    return (0);
+    return 0;
 }
 
 const char      *smb_session_server_name(smb_session *s)
 {
     if (s == NULL)
-        return (NULL);
+        return NULL;
     else
-        return (s->srv.name);
+        return s->srv.name;
 }
 
 int             smb_session_supports(smb_session *s, int what)
 {
     if (s == NULL)
-        return (0);
+        return 0;
 
     switch (what)
     {
         case SMB_SESSION_XSEC:
-            return (s->srv.caps & SMB_CAPS_XSEC);
+            return s->srv.caps & SMB_CAPS_XSEC;
         default:
-            return (0);
+            return 0;
     }
 }

src/smb_session_msg.c

@@ -49,11 +49,11 @@ int             smb_session_send_msg(smb_session *s, smb_message *msg)
 
     pkt_sz = sizeof(smb_packet) + msg->cursor;
     if (!s->transport.pkt_append(s->transport.session, (void *)msg->packet, pkt_sz))
-        return (0);
+        return 0;
     if (!s->transport.send(s->transport.session))
-        return (0);
+        return 0;
 
-    return (1);
+    return 1;
 }
 
 ssize_t         smb_session_recv_msg(smb_session *s, smb_message *msg)
@@ -65,7 +65,7 @@ ssize_t         smb_session_recv_msg(smb_session *s, smb_message *msg)
 
     payload_size = s->transport.recv(s->transport.session, &data);
     if (payload_size <= 0)
-        return (0);
+        return 0;
 
     if (msg != NULL)
     {
@@ -74,5 +74,5 @@ ssize_t         smb_session_recv_msg(smb_session *s, smb_message *msg)
         msg->cursor       = 0;
     }
 
-    return (payload_size - sizeof(smb_header));
+    return payload_size - sizeof(smb_header);
 }

src/smb_share.c

@@ -62,7 +62,7 @@ smb_tid         smb_tree_connect(smb_session *s, const char *name)
 
     req_msg = smb_message_new(SMB_CMD_TREE_CONNECT);
     if (!req_msg)
-        return (-1);
+        return -1;
 
     // Packet headers
     req_msg->packet->header.tid   = 0xffff; // Behavior of libsmbclient
@@ -85,19 +85,19 @@ smb_tid         smb_tree_connect(smb_session *s, const char *name)
     if (!smb_session_send_msg(s, req_msg))
     {
         smb_message_destroy(req_msg);
-        return (-1);
+        return -1;
     }
     smb_message_destroy(req_msg);
 
     if (!smb_session_recv_msg(s, &resp_msg))
-        return (-1);
+        return -1;
     if (resp_msg.packet->header.status != NT_STATUS_SUCCESS)
-        return (-1);
+        return -1;
 
     resp  = (smb_tree_connect_resp *)resp_msg.packet->payload;
     share = calloc(1, sizeof(smb_share));
     if (!share)
-        return (-1);
+        return -1;
 
     share->tid          = resp_msg.packet->header.tid;
     share->opts         = resp->opt_support;
@@ -106,7 +106,7 @@ smb_tid         smb_tree_connect(smb_session *s, const char *name)
 
     smb_session_share_add(s, share);
 
-    return (share->tid);
+    return share->tid;
 }
 
 int           smb_tree_disconnect(smb_session *s, smb_tid tid)
@@ -170,7 +170,7 @@ static size_t   smb_share_parse_enum(smb_message *msg, char ***list)
 
     *list       = calloc(share_count + 1, sizeof(char *));
     if (!list)
-        return (0);
+        return 0;
     assert(*list != NULL);
 
     for (i = 0; i < share_count && data < eod; i++)
@@ -191,7 +191,7 @@ static size_t   smb_share_parse_enum(smb_message *msg, char ***list)
         data    += com_len * 2;           // Move the pointer to next item
     }
 
-    return (i);
+    return i;
 }
 
 size_t          smb_share_list_count(smb_share_list list)
@@ -199,19 +199,19 @@ size_t          smb_share_list_count(smb_share_list list)
     size_t        res;
 
     if (list == NULL)
-        return (0);
+        return 0;
 
     for (res = 0; list[res] != NULL; res++)
         ;
 
-    return (res);
+    return res;
 }
 
 const char      *smb_share_list_at(smb_share_list list, size_t index)
 {
     assert(list != NULL);
 
-    return (list[index]);
+    return list[index];
 }
 
 void            smb_share_list_destroy(smb_share_list list)
@@ -241,18 +241,18 @@ size_t          smb_share_get_list(smb_session *s, char ***list)
 
     ipc_tid = smb_tree_connect(s, "IPC$");
     if (ipc_tid == -1)
-        return (0);
+        return 0;
 
     srvscv_fd = smb_fopen(s, ipc_tid, "\\srvsvc", SMB_MOD_RW);
     if (!srvscv_fd)
-        return (0);
+        return 0;
 
     //// Phase 1:
     // We bind a context or whatever for DCE/RPC
 
     req = smb_message_new(SMD_CMD_TRANS);
     if (!req)
-        return (0);
+        return 0;
     req->packet->header.tid = (uint16_t)ipc_tid;
 
     rpc_len = 0xffff;
@@ -305,7 +305,7 @@ size_t          smb_share_get_list(smb_session *s, char ***list)
     res = smb_session_send_msg(s, req);
     smb_message_destroy(req);
     if (!res)
-        return (0);
+        return 0;
 
     // Is the server throwing pile of shit back at me ?
     res = smb_session_recv_msg(s, &resp);
@@ -313,7 +313,7 @@ size_t          smb_share_get_list(smb_session *s, char ***list)
     {
         BDSM_dbg("Bind call failed: 0x%hhx (reason = 0x%hhx)\n",
                  resp.packet->payload[68], resp.packet->payload[70]);
-        return (0);
+        return 0;
     }
 
 
@@ -323,7 +323,7 @@ size_t          smb_share_get_list(smb_session *s, char ***list)
 
     req = smb_message_new(SMD_CMD_TRANS);
     if (!req)
-        return (0);
+        return 0;
     req->packet->header.tid = (uint16_t)ipc_tid;
 
     // this struct will be set at the end when we know the data size
@@ -390,14 +390,14 @@ size_t          smb_share_get_list(smb_session *s, char ***list)
     res = smb_session_send_msg(s, req);
     smb_message_destroy(req);
     if (!res)
-        return (0);
+        return 0;
 
     // Is the server throwing pile of shit back at me ?
     res = smb_session_recv_msg(s, &resp);
     if (!res && (uint32_t)resp.packet->payload[resp.payload_size - 4])
     {
         BDSM_dbg("NetShareEnumAll call failed.\n");
-        return (0);
+        return 0;
     }
 
 
@@ -408,5 +408,5 @@ size_t          smb_share_get_list(smb_session *s, char ***list)
     // Close the pipe
     smb_fclose(s, srvscv_fd);
 
-    return (res);
+    return res;
 }

src/smb_spnego.c

@@ -60,18 +60,18 @@ static int      init_asn1(smb_session *s)
     assert(s != NULL);
 
     if (s->spnego_asn1 != NULL)
-        return (1);
+        return 1;
 
     res = asn1_array2tree(spnego_asn1_conf, &s->spnego_asn1, NULL);
     if (res != ASN1_SUCCESS)
     {
         asn1_display_error("init_asn1", res);
-        return (0);
+        return 0;
     }
     else
     {
         BDSM_dbg("init_asn1: ASN.1 parser initialized\n");
-        return (1);
+        return 1;
     }
 }
 
@@ -94,7 +94,7 @@ static int      negotiate(smb_session *s, const char *domain)
 
     msg = smb_message_new(SMB_CMD_SETUP);
     if (!msg)
-        return (0);
+        return 0;
 
     // this struct will be set at the end when we know the payload size
     SMB_MSG_ADVANCE_PKT(msg, smb_session_xsec_req);
@@ -125,7 +125,7 @@ static int      negotiate(smb_session *s, const char *domain)
     {
         smb_message_destroy(msg);
         BDSM_dbg("Encoding error: %s", err_desc);
-        return (0);
+        return 0;
     }
 
     smb_message_append(msg, der, der_size);
@@ -152,16 +152,16 @@ static int      negotiate(smb_session *s, const char *domain)
     {
         smb_message_destroy(msg);
         BDSM_dbg("Unable to send Session Setup AndX (NTLMSSP_NEGOTIATE) message\n");
-        return (0);
+        return 0;
     }
 
     smb_message_destroy(msg);
-    return (1);
+    return 1;
 
 error:
     asn1_display_error("smb_session_login negotiate()", res);
     smb_message_destroy(msg);
-    return (0);
+    return 0;
 }
 
 static int      challenge(smb_session *s)
@@ -179,14 +179,14 @@ static int      challenge(smb_session *s)
     if (smb_session_recv_msg(s, &msg) == 0)
     {
         BDSM_dbg("spnego challenge(): Unable to receive message\n");
-        return (0);
+        return 0;
     }
 
     if (msg.packet->header.status != NT_STATUS_MORE_PROCESSING_REQUIRED)
     {
         BDSM_dbg("spnego challenge(): Bad status (0x%x)\n",
                  msg.packet->header.status);
-        return (0);
+        return 0;
     }
 
     resp = (smb_session_xsec_resp *)msg.packet->payload;
@@ -199,7 +199,7 @@ static int      challenge(smb_session *s)
         asn1_delete_structure(&token);
         asn1_display_error("NegTokenResp parsing", res);
         BDSM_dbg("Parsing error detail: %s\n", err_desc);
-        return (0);
+        return 0;
     }
 
     // XXX Check the value of "negTokenResp.negResult"
@@ -210,13 +210,13 @@ static int      challenge(smb_session *s)
     if (res != ASN1_SUCCESS)
     {
         asn1_display_error("NegTokenResp read responseToken", res);
-        return (0);
+        return 0;
     }
 
     // We got the server challenge, yeaaah.
     challenge = (smb_ntlmssp_challenge *)resp_token;
     if (smb_buffer_alloc(&s->xsec_target, challenge->tgt_len) == 0)
-        return (0);
+        return 0;
     memcpy(s->xsec_target.data,
            challenge->data + challenge->tgt_offset - sizeof(smb_ntlmssp_challenge),
            s->xsec_target.size);
@@ -225,7 +225,7 @@ static int      challenge(smb_session *s)
 
     BDSM_dbg("Server challenge is 0x%"PRIx64"\n", s->srv.challenge);
 
-    return (1);
+    return 1;
 }
 
 static int      auth(smb_session *s, const char *domain, const char *user,
@@ -240,7 +240,7 @@ static int      auth(smb_session *s, const char *domain, const char *user,
 
     msg = smb_message_new(SMB_CMD_SETUP);
     if (!msg)
-        return (0);
+        return 0;
 
     // this struct will be set at the end when we know the payload size
     SMB_MSG_ADVANCE_PKT(msg, smb_session_xsec_req);
@@ -272,7 +272,7 @@ static int      auth(smb_session *s, const char *domain, const char *user,
     {
         smb_message_destroy(msg);
         BDSM_dbg("Encoding error: %s", err_desc);
-        return (0);
+        return 0;
     }
 
     smb_message_append(msg, der, der_size);
@@ -301,15 +301,15 @@ static int      auth(smb_session *s, const char *domain, const char *user,
     {
         smb_message_destroy(msg);
         BDSM_dbg("Unable to send Session Setup AndX (NTLMSSP_AUTH) message\n");
-        return (0);
+        return 0;
     }
     smb_message_destroy(msg);
 
     if (smb_session_recv_msg(s, &resp) == 0)
-        return (0);
+        return 0;
 
     if (resp.packet->header.status != NT_STATUS_SUCCESS)
-        return (0);
+        return 0;
     else
     {
         smb_session_xsec_resp *r = (smb_session_xsec_resp *)resp.packet->payload;
@@ -319,13 +319,13 @@ static int      auth(smb_session *s, const char *domain, const char *user,
         s->srv.uid  = resp.packet->header.uid;
         s->state    = SMB_STATE_SESSION_OK;
 
-        return (1);
+        return 1;
     }
 
 error:
     asn1_display_error("smb_session_login auth()", res);
     smb_message_destroy(msg);
-    return (0);
+    return 0;
 }
 
 int             smb_session_login_spnego(smb_session *s, const char *domain,
@@ -338,7 +338,7 @@ int             smb_session_login_spnego(smb_session *s, const char *domain,
     s->srv.uid = 0;
 
     if (!init_asn1(s))
-        return (0);
+        return 0;
 
     if (!negotiate(s, domain))
         goto error;
@@ -349,11 +349,11 @@ int             smb_session_login_spnego(smb_session *s, const char *domain,
 
     clean_asn1(s);
 
-    return (res);
+    return res;
 
 error:
     BDSM_dbg("login_spnego Interrupted\n");
     clean_asn1(s);
-    return (0);
+    return 0;
 }
 

src/smb_stat.c

@@ -37,7 +37,7 @@ smb_stat        smb_stat_fd(smb_session *s, smb_fd fd)
 {
     assert(s != NULL && fd);
 
-    return (smb_session_file_get(s, fd));
+    return smb_session_file_get(s, fd);
 }
 
 void            smb_stat_destroy(smb_stat stat) 
@@ -55,7 +55,7 @@ size_t            smb_stat_list_count(smb_stat_list list)
         ++count;
     }
 
-    return (count);
+    return count;
 }
 
 // XXX: Duplicate some code of smb_session_share_clear
@@ -82,39 +82,39 @@ smb_stat        smb_stat_list_at(smb_stat_list list, size_t index)
         pos++;
     }
 
-    return (list);
+    return list;
 }
 
 const char        *smb_stat_name(smb_stat info)
 {
     if (info == NULL)
-        return (NULL);
+        return NULL;
     else
-        return (info->name);
+        return info->name;
 }
 
 uint64_t          smb_stat_get(smb_stat info, int what)
 {
     if (info == NULL)
-        return (0);
+        return 0;
 
     switch (what)
     {
         case SMB_STAT_SIZE:
-            return (info->size);
+            return info->size;
         case SMB_STAT_ALLOC_SIZE:
-            return (info->alloc_size);
+            return info->alloc_size;
         case SMB_STAT_CTIME:
-            return (info->created);
+            return info->created;
         case SMB_STAT_ATIME:
-            return (info->accessed);
+            return info->accessed;
         case SMB_STAT_WTIME:
-            return (info->written);
+            return info->written;
         case SMB_STAT_MTIME:
-            return (info->changed);
+            return info->changed;
         case SMB_STAT_ISDIR:
-            return (info->is_dir);
+            return info->is_dir;
         default:
-            return (0);
+            return 0;
     }
 }

src/smb_trans2.c

@@ -51,12 +51,12 @@ static smb_message *smb_tr2_recv(smb_session *s)
     int                   remaining;
 
     if (!smb_session_recv_msg(s, &recv))
-        return (NULL);
+        return NULL;
     tr2         = (smb_trans2_resp *)recv.packet->payload;
     growth      = tr2->total_data_count - tr2->data_count;
     res         = smb_message_grow(&recv, growth);
     if (!res)
-        return (NULL);
+        return NULL;
     res->cursor = recv.payload_size;
     remaining   = (int)tr2->total_data_count -
                   (tr2->data_displacement + tr2->data_count);
@@ -77,7 +77,7 @@ static smb_message *smb_tr2_recv(smb_session *s)
         }
     }
 
-    return (res);
+    return res;
 }
 
 /*
@@ -173,7 +173,7 @@ static smb_message  *smb_trans2_find_first (smb_session *s, smb_tid tid, const c
 
     utf_pattern_len = smb_to_utf16(pattern, strlen(pattern) + 1, &utf_pattern);
     if (utf_pattern_len == 0)
-        return (NULL);
+        return NULL;
 
     tr2_bct = sizeof(smb_tr2_findfirst2) + utf_pattern_len;
     tr2_param_count = tr2_bct;
@@ -188,7 +188,7 @@ static smb_message  *smb_trans2_find_first (smb_session *s, smb_tid tid, const c
     msg = smb_message_new(SMB_CMD_TRANS2);
     if (!msg) {
         free(utf_pattern);
-        return (NULL);
+        return NULL;
     }
     msg->packet->header.tid = (uint16_t)tid;
 
@@ -223,7 +223,7 @@ static smb_message  *smb_trans2_find_first (smb_session *s, smb_tid tid, const c
     if (!res)
     {
         BDSM_dbg("Unable to query pattern: %s\n", pattern);
-        return (NULL);
+        return NULL;
     }
 
     msg = smb_tr2_recv(s);
@@ -244,7 +244,7 @@ static smb_message  *smb_trans2_find_next (smb_session *s, smb_tid tid, uint16_t
 
     utf_pattern_len = smb_to_utf16(pattern, strlen(pattern) + 1, &utf_pattern);
     if (utf_pattern_len == 0)
-        return (NULL);
+        return NULL;
 
     tr2_bct = sizeof(smb_tr2_findnext2) + utf_pattern_len;
     tr2_param_count = tr2_bct;
@@ -298,7 +298,7 @@ static smb_message  *smb_trans2_find_next (smb_session *s, smb_tid tid, uint16_t
     if (!res)
     {
         BDSM_dbg("Unable to query pattern: %s\n", pattern);
-        return (NULL);
+        return NULL;
     }
 
     msg_find_next2 = smb_tr2_recv(s);
@@ -383,7 +383,7 @@ smb_file  *smb_find(smb_session *s, smb_tid tid, const char *pattern)
         smb_message_destroy(msg);
     }
 
-    return (files);
+    return files;
 }
 
 /*
@@ -406,7 +406,7 @@ smb_file  *smb_fstat(smb_session *s, smb_tid tid, const char *path)
 
     utf_path_len = smb_to_utf16(path, strlen(path) + 1, &utf_path);
     if (utf_path_len == 0)
-        return (0);
+        return 0;
 
     msg_len   = sizeof(smb_trans2_req) + sizeof(smb_tr2_query);
     msg_len  += utf_path_len;
@@ -416,7 +416,7 @@ smb_file  *smb_fstat(smb_session *s, smb_tid tid, const char *path)
     msg = smb_message_new(SMB_CMD_TRANS2);
     if (!msg) {
         free(utf_path);
-        return (0);
+        return 0;
     }
     msg->packet->header.tid = (uint16_t)tid;
 
@@ -450,21 +450,21 @@ smb_file  *smb_fstat(smb_session *s, smb_tid tid, const char *path)
     if (!res)
     {
         BDSM_dbg("Unable to query pattern: %s\n", path);
-        return (NULL);
+        return NULL;
     }
 
     if (!smb_session_recv_msg(s, &reply)
         || reply.packet->header.status != NT_STATUS_SUCCESS)
     {
         BDSM_dbg("Unable to recv msg or failure for %s\n", path);
-        return (NULL);
+        return NULL;
     }
 
     tr2_resp  = (smb_trans2_resp *)reply.packet->payload;
     info      = (smb_tr2_path_info *)(tr2_resp->payload + 4); //+4 is padding
     file      = calloc(1, sizeof(smb_file));
     if (!file)
-        return (NULL);
+        return NULL;
 
     file->name_len  = smb_from_utf16((const char *)info->name, info->name_len,
                                      &file->name);
@@ -479,5 +479,5 @@ smb_file  *smb_fstat(smb_session *s, smb_tid tid, const char *path)
     file->attr        = info->attr;
     file->is_dir      = info->is_dir;
 
-    return (file);
+    return file;
 }

src/smb_transport.c

@@ -39,14 +39,14 @@ int               transport_connect_nbt(struct in_addr *addr,
                                         netbios_session *s,
                                         const char *name)
 {
-    return (netbios_session_connect(addr, s, name, 0));
+    return netbios_session_connect(addr, s, name, 0);
 }
 
 int               transport_connect_tcp(struct in_addr *addr,
                                         netbios_session *s,
                                         const char *name)
 {
-    return (netbios_session_connect(addr, s, name, 1));
+    return netbios_session_connect(addr, s, name, 1);
 }
 
 void              smb_transport_nbt(smb_transport *tr)

src/smb_utils.c

@@ -48,9 +48,9 @@
 static const char *current_encoding()
 {
 #if defined( __APPLE__ )
-    return ("UTF8");
+    return "UTF8";
 #elif !HAVE_LANGINFO_H
-    return ("UTF-8");
+    return "UTF-8";
 #else
     static int locale_set = 0;
 
@@ -60,7 +60,7 @@ static const char *current_encoding()
         locale_set = 1;
     }
     //BDSM_dbg("%s\n", nl_langinfo(CODESET));
-    return (nl_langinfo(CODESET));
+    return nl_langinfo(CODESET);
 #endif
 }
 
@@ -75,7 +75,7 @@ static size_t smb_iconv(const char *src, size_t src_len, char **dst,
     if (!src_len)
     {
         *dst = NULL;
-        return (0);
+        return 0;
     }
 
     if ((ic = iconv_open(dst_enc, src_enc)) == (iconv_t)-1)
@@ -83,7 +83,7 @@ static size_t smb_iconv(const char *src, size_t src_len, char **dst,
         BDSM_dbg("Unable to open iconv to convert from %s to %s\n",
                  src_enc, dst_enc);
         *dst = NULL;
-        return (0);
+        return 0;
     }
     for (unsigned mul = 4; mul < 16; mul++)
     {
@@ -110,7 +110,7 @@ static size_t smb_iconv(const char *src, size_t src_len, char **dst,
 
     if (ret == 0)
         *dst = NULL;
-    return (ret);
+    return ret;
 }
 
 size_t      smb_to_utf16(const char *src, size_t src_len, char **dst)