[balsa] libnetclient: use G_DECLARE*
- From: Peter Bloomfield <peterb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [balsa] libnetclient: use G_DECLARE*
- Date: Sun, 2 Jun 2019 18:00:43 +0000 (UTC)
commit 713d66e3b0d959bc630f7b6ce7f94868f1c81383
Author: Albrecht Dreß <albrecht dress arcor de>
Date: Sun Jun 2 13:59:55 2019 -0400
libnetclient: use G_DECLARE*
* libnetclient/net-client-pop.[ch]: use G_DECLARE_FINAL_TYPE(),
and drop storing the private object data in a separate structure;
• net_client_pop_get_capa(): enable pipelining only if included
in the server's capabilities
* libnetclient/net-client-siobuf.[ch], libnetclient/net-client-smtp.[ch]:
use G_DECLARE_FINAL_TYPE(), and drop storing the private object
data in a separate structure
* libnetclient/net-client-utils.h: suppress Flexelint 9.00 false-positive
* libnetclient/net-client.[hc]: use G_DECLARE_DERIVABLE_TYPE();
use net_client_get_instance_private() to access private data
ChangeLog | 15 +++
libnetclient/net-client-pop.c | 67 +++++------
libnetclient/net-client-pop.h | 25 +---
libnetclient/net-client-siobuf.c | 94 +++++++--------
libnetclient/net-client-siobuf.h | 27 +----
libnetclient/net-client-smtp.c | 55 ++++-----
libnetclient/net-client-smtp.h | 25 +---
libnetclient/net-client-utils.h | 1 +
libnetclient/net-client.c | 243 +++++++++++++++++++++++----------------
libnetclient/net-client.h | 32 ++----
10 files changed, 283 insertions(+), 301 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index d7117c19f..0ade90b46 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,18 @@
+2019-06-02 Albrecht Dreß <albrecht dress arcor de>
+
+ libnetclient: use G_DECLARE*
+
+ * libnetclient/net-client-pop.[ch]: use G_DECLARE_FINAL_TYPE(),
+ and drop storing the private object data in a separate structure;
+ • net_client_pop_get_capa(): enable pipelining only if included
+ in the server's capabilities
+ * libnetclient/net-client-siobuf.[ch], libnetclient/net-client-smtp.[ch]:
+ use G_DECLARE_FINAL_TYPE(), and drop storing the private object
+ data in a separate structure
+ * libnetclient/net-client-utils.h: suppress Flexelint 9.00 false-positive
+ * libnetclient/net-client.[hc]: use G_DECLARE_DERIVABLE_TYPE();
+ use net_client_get_instance_private() to access private data
+
2019-05-27 Peter Bloomfield <pbloomfield bellsouth net>
* libbalsa/imap/imap-commands.h: remove redundant declaration of
diff --git a/libnetclient/net-client-pop.c b/libnetclient/net-client-pop.c
index ec96a88a6..2c92e5dfc 100644
--- a/libnetclient/net-client-pop.c
+++ b/libnetclient/net-client-pop.c
@@ -19,7 +19,10 @@
#include "net-client-pop.h"
-struct _NetClientPopPrivate {
+/*lint -esym(754,_NetClientPop::parent) required field, not referenced directly */
+struct _NetClientPop {
+ NetClient parent;
+
NetClientCryptMode crypt_mode;
gchar *apop_banner;
guint auth_allowed[2]; /** 0: encrypted, 1: unencrypted */
@@ -44,7 +47,8 @@ struct _NetClientPopPrivate {
/*lint -restore */
-G_DEFINE_TYPE_WITH_PRIVATE(NetClientPop, net_client_pop, NET_CLIENT_TYPE)
+/*lint -esym(528,net_client_pop_get_instance_private) auto-generated function, not referenced */
+G_DEFINE_TYPE(NetClientPop, net_client_pop, NET_CLIENT_TYPE)
static void net_client_pop_finalise(GObject *object);
@@ -82,8 +86,8 @@ net_client_pop_new(const gchar *host, guint16 port, NetClientCryptMode crypt_mod
g_object_unref(G_OBJECT(client));
client = NULL;
} else {
- client->priv->crypt_mode = crypt_mode;
- client->priv->use_pipelining = use_pipelining;
+ client->crypt_mode = crypt_mode;
+ client->use_pipelining = use_pipelining;
}
}
@@ -97,9 +101,9 @@ net_client_pop_allow_auth(NetClientPop *client, gboolean encrypted, guint allow_
/* paranoia check */
g_return_val_if_fail(NET_IS_CLIENT_POP(client), FALSE);
if (encrypted) {
- client->priv->auth_allowed[0] = allow_auth;
+ client->auth_allowed[0] = allow_auth;
} else {
- client->priv->auth_allowed[1] = allow_auth;
+ client->auth_allowed[1] = allow_auth;
}
return TRUE;
}
@@ -117,7 +121,7 @@ net_client_pop_connect(NetClientPop *client, gchar **greeting, GError **error)
/* establish connection, and immediately switch to TLS if required */
result = net_client_connect(NET_CLIENT(client), error);
- if (result && (client->priv->crypt_mode == NET_CLIENT_CRYPT_ENCRYPTED)) {
+ if (result && (client->crypt_mode == NET_CLIENT_CRYPT_ENCRYPTED)) {
result = net_client_start_tls(NET_CLIENT(client), error);
}
@@ -130,14 +134,15 @@ net_client_pop_connect(NetClientPop *client, gchar **greeting, GError **error)
if (result) {
const gchar *ang_open;
- ang_open = strchr(server_msg, '<'); /*lint !e668 !e9034 server_msg
cannot be NULL; accept char literal as int */
+ /*lint -e{668,9034} server_msg cannot be NULL; accept char literal as int (MISRA
C:2012 Rule 10.3) */
+ ang_open = strchr(server_msg, '<');
if (ang_open != NULL) {
const gchar *ang_close;
- ang_close = strchr(ang_open, '>'); /*lint !e9034 accept char literal as int */
+ ang_close = strchr(ang_open, '>'); /*lint !e9034 accept char literal as int
(MISRA C:2012 Rule 10.3) */
if (ang_close != NULL) {
/*lint -e{737,946,947,9029} allowed exception according to MISRA Rules
18.2 and 18.3 */
- client->priv->apop_banner = g_strndup(ang_open, (ang_close - ang_open) + 1U);
+ client->apop_banner = g_strndup(ang_open, (ang_close - ang_open) + 1U);
auth_supported = NET_CLIENT_POP_AUTH_APOP;
}
}
@@ -149,10 +154,10 @@ net_client_pop_connect(NetClientPop *client, gchar **greeting, GError **error)
/* perform STLS if required- note that some servers support STLS, but do not announce it. So just
try... */
if (result &&
- ((client->priv->crypt_mode == NET_CLIENT_CRYPT_STARTTLS) || (client->priv->crypt_mode ==
NET_CLIENT_CRYPT_STARTTLS_OPT))) {
+ ((client->crypt_mode == NET_CLIENT_CRYPT_STARTTLS) || (client->crypt_mode ==
NET_CLIENT_CRYPT_STARTTLS_OPT))) {
result = net_client_pop_starttls(client, error);
if (!result) {
- if (client->priv->crypt_mode == NET_CLIENT_CRYPT_STARTTLS_OPT) {
+ if (client->crypt_mode == NET_CLIENT_CRYPT_STARTTLS_OPT) {
result = TRUE;
g_clear_error(error);
}
@@ -183,7 +188,7 @@ net_client_pop_connect(NetClientPop *client, gchar **greeting, GError **error)
g_debug("passwordless authentication failed, retry w/ password: emit 'auth'
signal for client %p", client);
g_clear_error(error);
g_free(auth_data);
- g_signal_emit_by_name(client, "auth", TRUE, &auth_data);
+ g_signal_emit_by_name(client, "auth", TRUE, &auth_data); /*lint !e730
passing a gboolean is intended here */
if ((auth_data != NULL) && (auth_data[0] != NULL)) {
result = net_client_pop_auth(client, auth_data[0], auth_data[1],
auth_supported & ~NET_CLIENT_POP_AUTH_NO_PWD, error);
@@ -275,12 +280,12 @@ net_client_pop_list(NetClientPop *client, GList **msg_list, gboolean with_uid, G
}
/* get all uid's if requested */
- if (result && with_uid && client->priv->can_uidl && (*msg_list != NULL)) {
+ if (result && with_uid && client->can_uidl && (*msg_list != NULL)) {
result = net_client_pop_uidl(client, msg_list, error);
}
if (!result) {
- /*lint -e{9074,9087} accept sane pointer conversion */
+ /*lint -e{9074,9087} accept sane pointer conversion (MISRA C:2012 Rules 11.1, 11.3) */
g_list_free_full(*msg_list, (GDestroyNotify) net_client_pop_msg_info_free);
}
@@ -299,7 +304,7 @@ net_client_pop_retr(NetClientPop *client, GList *msg_list, NetClientPopMsgCb cal
g_return_val_if_fail(NET_IS_CLIENT_POP(client) && (msg_list != NULL) && (callback != NULL), FALSE);
/* pipelining: send all RETR commands */
- pipelining = client->priv->can_pipelining && client->priv->use_pipelining;
+ pipelining = client->can_pipelining && client->use_pipelining;
if (pipelining) {
GString *retr_buf;
@@ -341,7 +346,7 @@ net_client_pop_dele(NetClientPop *client, GList *msg_list, GError **error)
g_return_val_if_fail(NET_IS_CLIENT_POP(client) && (msg_list != NULL), FALSE);
/* pipelining: send all DELE commands */
- pipelining = client->priv->can_pipelining && client->priv->use_pipelining;
+ pipelining = client->can_pipelining && client->use_pipelining;
if (pipelining) {
GString *dele_buf;
@@ -394,16 +399,15 @@ net_client_pop_class_init(NetClientPopClass *klass)
static void
net_client_pop_init(NetClientPop *self)
{
- self->priv = net_client_pop_get_instance_private(self); /*lint !e9079 (MISRA C:2012 Rule
11.5) intended use */
- self->priv->auth_allowed[0] = NET_CLIENT_POP_AUTH_ALL;
- self->priv->auth_allowed[1] = NET_CLIENT_POP_AUTH_SAFE;
+ self->auth_allowed[0] = NET_CLIENT_POP_AUTH_ALL;
+ self->auth_allowed[1] = NET_CLIENT_POP_AUTH_SAFE;
}
static void
net_client_pop_finalise(GObject *object)
{
- const NetClientPop *client = NET_CLIENT_POP(object);
+ NetClientPop *client = NET_CLIENT_POP(object);
const GObjectClass *parent_class = G_OBJECT_CLASS(net_client_pop_parent_class);
/* send the 'QUIT' command - no need to evaluate the reply or check for errors */
@@ -411,7 +415,7 @@ net_client_pop_finalise(GObject *object)
(void) net_client_execute(NET_CLIENT(client), NULL, "QUIT", NULL);
}
- g_free(client->priv->apop_banner);
+ g_free(client->apop_banner);
(*parent_class->finalize)(object);
}
@@ -462,7 +466,7 @@ net_client_pop_execute(NetClientPop *client, const gchar *request_fmt, gchar **l
va_list args;
gboolean result;
- va_start(args, error); /*lint !e413 a NULL error argument is irrelevant here */
+ va_start(args, error);
result = net_client_vwrite_line(NET_CLIENT(client), request_fmt, args, error);
va_end(args);
@@ -495,9 +499,9 @@ net_client_pop_auth(NetClientPop *client, const gchar *user, const gchar *passwd
guint auth_mask;
if (net_client_is_encrypted(NET_CLIENT(client))) {
- auth_mask = client->priv->auth_allowed[0] & auth_supported;
+ auth_mask = client->auth_allowed[0] & auth_supported;
} else {
- auth_mask = client->priv->auth_allowed[1] & auth_supported;
+ auth_mask = client->auth_allowed[1] & auth_supported;
}
if (auth_mask == 0U) {
@@ -601,7 +605,7 @@ net_client_pop_auth_apop(NetClientPop *client, const gchar *user, const gchar *p
gchar *auth_buf;
gchar *md5_buf;
- auth_buf = g_strconcat(client->priv->apop_banner, passwd, NULL);
+ auth_buf = g_strconcat(client->apop_banner, passwd, NULL);
md5_buf = g_compute_checksum_for_string(G_CHECKSUM_MD5, auth_buf, -1);
net_client_free_authstr(auth_buf);
result = net_client_pop_execute(client, "APOP %s %s", NULL, error, user, md5_buf);
@@ -683,7 +687,7 @@ net_client_pop_auth_gssapi(NetClientPop *client, const gchar *user, GError **err
#else
-/*lint -e{715} -e{818} */
+/*lint -e{715,818} */
static gboolean
net_client_pop_auth_gssapi(NetClientPop G_GNUC_UNUSED *client, const gchar G_GNUC_UNUSED *user, GError
G_GNUC_UNUSED **error)
{
@@ -701,7 +705,7 @@ net_client_pop_execute_sasl(NetClientPop *client, const gchar *request_fmt, gcha
va_list args;
gboolean result;
- va_start(args, error); /*lint !e413 a NULL error argument is irrelevant here */
+ va_start(args, error);
result = net_client_vwrite_line(NET_CLIENT(client), request_fmt, args, error);
va_end(args);
@@ -734,7 +738,7 @@ net_client_pop_get_capa(NetClientPop *client, guint *auth_supported)
/* clear all capability flags except APOP and send the CAPA command */
*auth_supported = *auth_supported & NET_CLIENT_POP_AUTH_APOP;
- client->priv->can_pipelining = FALSE;
+ client->can_pipelining = FALSE;
result = net_client_pop_execute(client, "CAPA", NULL, NULL);
/* evaluate the response */
@@ -772,9 +776,9 @@ net_client_pop_get_capa(NetClientPop *client, guint *auth_supported)
}
g_strfreev(auth);
} else if (strcmp(reply, "PIPELINING") == 0) {
- client->priv->can_pipelining = TRUE;
+ client->can_pipelining = TRUE;
} else if (strcmp(reply, "UIDL") == 0) {
- client->priv->can_uidl = TRUE;
+ client->can_uidl = TRUE;
} else {
/* ignore this capability (see MISRA C:2012, Rule 15.7) */
}
@@ -788,7 +792,6 @@ net_client_pop_get_capa(NetClientPop *client, guint *auth_supported)
if (*auth_supported == 0U) {
*auth_supported = NET_CLIENT_POP_AUTH_USER_PASS;
}
- client->priv->can_pipelining = TRUE;
}
diff --git a/libnetclient/net-client-pop.h b/libnetclient/net-client-pop.h
index e94743c2b..696599708 100644
--- a/libnetclient/net-client-pop.h
+++ b/libnetclient/net-client-pop.h
@@ -23,18 +23,12 @@ G_BEGIN_DECLS
#define NET_CLIENT_POP_TYPE (net_client_pop_get_type())
-#define NET_CLIENT_POP(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
NET_CLIENT_POP_TYPE, NetClientPop))
-#define NET_IS_CLIENT_POP(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
NET_CLIENT_POP_TYPE))
-#define NET_CLIENT_POP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
NET_CLIENT_POP_TYPE, NetClientPopClass))
-#define NET_IS_CLIENT_POP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NET_CLIENT_POP_TYPE))
-#define NET_CLIENT_POP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), NET_CLIENT_POP_TYPE,
NetClientPopClass))
+G_DECLARE_FINAL_TYPE(NetClientPop, net_client_pop, NET, CLIENT_POP, NetClient)
+
#define NET_CLIENT_POP_ERROR_QUARK (g_quark_from_static_string("net-client-pop"))
-typedef struct _NetClientPop NetClientPop;
-typedef struct _NetClientPopClass NetClientPopClass;
-typedef struct _NetClientPopPrivate NetClientPopPrivate;
typedef struct _NetClientPopMessage NetClientPopMessage;
typedef struct _NetClientPopMessageInfo NetClientPopMessageInfo;
@@ -80,17 +74,6 @@ enum _NetClientPopError {
/** @} */
-struct _NetClientPop {
- NetClient parent;
- NetClientPopPrivate *priv;
-};
-
-
-struct _NetClientPopClass {
- NetClientClass parent;
-};
-
-
/** @brief Message information
*
* This structure is returned in a GList by net_client_pop_list() and contains information about on message
in the remote mailbox.
@@ -132,10 +115,6 @@ typedef gboolean (*NetClientPopMsgCb)(const gchar *buffer, gssize count, gsize l
gpointer user_data, GError **error);
-GType net_client_pop_get_type(void)
- G_GNUC_CONST;
-
-
/** @brief Create a new POP network client
*
* @param host host name or IP address to connect
diff --git a/libnetclient/net-client-siobuf.c b/libnetclient/net-client-siobuf.c
index 3b8dc70ac..af2c0c823 100644
--- a/libnetclient/net-client-siobuf.c
+++ b/libnetclient/net-client-siobuf.c
@@ -19,14 +19,18 @@
#include "net-client-siobuf.h"
-struct _NetClientSioBufPrivate {
+/*lint -esym(754,_NetClientSioBuf::parent) required field, not referenced directly */
+struct _NetClientSioBuf {
+ NetClient parent;
+
GString *buffer; /**< hold a line read from the remote server, including the
terminating CRLF */
gchar *read_ptr; /**< point to the next char which shall be read in buffer's
GString::str. */
GString *writebuf; /**< buffer for buffered write functions */
};
-G_DEFINE_TYPE_WITH_PRIVATE(NetClientSioBuf, net_client_siobuf, NET_CLIENT_TYPE)
+/*lint -esym(528,net_client_siobuf_get_instance_private) auto-generated function, not
referenced */
+G_DEFINE_TYPE(NetClientSioBuf, net_client_siobuf, NET_CLIENT_TYPE)
static void net_client_siobuf_finalise(GObject *object);
@@ -46,9 +50,9 @@ net_client_siobuf_new(const gchar *host, guint16 port)
g_object_unref(G_OBJECT(client));
client = NULL;
} else {
- client->priv->buffer = g_string_sized_new(1024U);
- client->priv->read_ptr = NULL;
- client->priv->writebuf = g_string_sized_new(1024U);
+ client->buffer = g_string_sized_new(1024U);
+ client->read_ptr = NULL;
+ client->writebuf = g_string_sized_new(1024U);
}
}
@@ -59,39 +63,37 @@ net_client_siobuf_new(const gchar *host, guint16 port)
gint
net_client_siobuf_read(NetClientSioBuf *client, void *buffer, gsize count, GError **error)
{
- NetClientSioBufPrivate *priv;
gboolean fill_res;
gchar *dest;
gsize left;
g_return_val_if_fail(NET_IS_CLIENT_SIOBUF(client) && (buffer != NULL) && (count > 0U), -1);
- priv = client->priv;
- dest = (gchar *) buffer;
+ dest = (gchar *) buffer; /*lint !e9079 sane pointer conversion (MISRA C:2012 Rule 11.5) */
left = count;
fill_res = net_client_siobuf_fill(client, error);
while (fill_res && (left > 0U)) {
gsize avail;
gsize chunk;
- /*lint -e{737,946,947,9029} allowed exception according to MISRA Rules 18.2 and
18.3 */
- avail = priv->buffer->len - (priv->read_ptr - priv->buffer->str);
+ /*lint -e{737,946,947,9029} allowed exception according to MISRA C:2012 Rules
18.2, 18.3 */
+ avail = client->buffer->len - (client->read_ptr - client->buffer->str);
if (avail > left) {
chunk = left;
} else {
chunk = avail;
}
- memcpy(dest, priv->read_ptr, chunk);
+ memcpy(dest, client->read_ptr, chunk);
dest += chunk;
- priv->read_ptr += chunk;
+ client->read_ptr += chunk;
left -= chunk;
if (left > 0U) {
fill_res = net_client_siobuf_fill(client, error);
}
}
- return (left < count) ? (gint) (count - left) : -1;
+ return (left < count) ? ((gint) count - (gint) left) : -1;
}
@@ -103,7 +105,7 @@ net_client_siobuf_getc(NetClientSioBuf *client, GError **error)
g_return_val_if_fail(NET_IS_CLIENT_SIOBUF(client), -1);
if (net_client_siobuf_fill(client, error)) {
- retval = *client->priv->read_ptr++;
+ retval = (gint) *client->read_ptr++;
} else {
retval = -1;
}
@@ -114,15 +116,13 @@ net_client_siobuf_getc(NetClientSioBuf *client, GError **error)
gint
net_client_siobuf_ungetc(NetClientSioBuf *client)
{
- NetClientSioBufPrivate *priv;
gint retval;
g_return_val_if_fail(NET_IS_CLIENT_SIOBUF(client), -1);
- priv = client->priv;
- /*lint -e{946} allowed exception according to MISRA Rules 18.2 and 18.3 */
- if ((priv->buffer->len != 0U) && (priv->read_ptr > priv->buffer->str)) {
- priv->read_ptr--;
+ /*lint -e{946} allowed exception according to MISRA C:2012 Rules 18.2 and 18.3 */
+ if ((client->buffer->len != 0U) && (client->read_ptr > client->buffer->str)) {
+ client->read_ptr--;
retval = 0;
} else {
retval = -1;
@@ -134,25 +134,23 @@ net_client_siobuf_ungetc(NetClientSioBuf *client)
gchar *
net_client_siobuf_gets(NetClientSioBuf *client, gchar *buffer, gsize buflen, GError **error)
{
- NetClientSioBufPrivate *priv;
gchar *result;
g_return_val_if_fail(NET_IS_CLIENT_SIOBUF(client) && (buffer != NULL) && (buflen > 0U), NULL);
- priv = client->priv;
if (net_client_siobuf_fill(client, error)) {
gsize avail;
gsize chunk;
- /*lint -e{737,946,947,9029} allowed exception according to MISRA Rules 18.2 and
18.3 */
- avail = priv->buffer->len - (priv->read_ptr - priv->buffer->str);
+ /*lint -e{737,946,947,9029} allowed exception according to MISRA C:2012 Rules
18.2 and 18.3 */
+ avail = client->buffer->len - (client->read_ptr - client->buffer->str);
if (avail > (buflen - 1U)) {
chunk = buflen - 1U;
} else {
chunk = avail;
}
- memcpy(buffer, priv->read_ptr, chunk);
- priv->read_ptr += chunk;
+ memcpy(buffer, client->read_ptr, chunk);
+ client->read_ptr += chunk;
buffer[chunk] = '\0';
result = buffer;
} else {
@@ -166,23 +164,21 @@ net_client_siobuf_gets(NetClientSioBuf *client, gchar *buffer, gsize buflen, GEr
gchar *
net_client_siobuf_get_line(NetClientSioBuf *client, GError **error)
{
- const NetClientSioBufPrivate *priv;
gchar *result;
g_return_val_if_fail(NET_IS_CLIENT_SIOBUF(client), NULL);
- priv = client->priv;
if (net_client_siobuf_fill(client, error)) {
gsize avail;
- /*lint -e{737,946,947,9029} allowed exception according to MISRA Rules 18.2 and
18.3 */
- avail = priv->buffer->len - (priv->read_ptr - priv->buffer->str);
+ /*lint -e{737,946,947,9029} allowed exception according to MISRA C:2012 Rules
18.2 and 18.3 */
+ avail = client->buffer->len - (client->read_ptr - client->buffer->str);
if (avail > 2U) {
- result = g_strndup(priv->read_ptr, avail - 2U);
+ result = g_strndup(client->read_ptr, avail - 2U);
} else {
result = g_strdup("");
}
- priv->buffer->len = 0U;
+ client->buffer->len = 0U;
} else {
result = NULL;
}
@@ -199,8 +195,8 @@ net_client_siobuf_discard_line(NetClientSioBuf *client, GError **error)
g_return_val_if_fail(NET_IS_CLIENT_SIOBUF(client), -1);
if (net_client_siobuf_fill(client, error)) {
- client->priv->buffer->len = 0U;
- result = '\n';
+ client->buffer->len = 0U;
+ result = (gint) '\n';
} else {
result = -1;
}
@@ -214,7 +210,8 @@ net_client_siobuf_write(NetClientSioBuf *client, const void *buffer, gsize count
{
g_return_if_fail(NET_IS_CLIENT_SIOBUF(client) && (buffer != NULL) && (count > 0U));
- (void) g_string_append_len(client->priv->writebuf, (const gchar *) buffer, (gssize) count);
+ /*lint -e{9079} sane pointer conversion (MISRA C:2012 Rule 11.5) */
+ (void) g_string_append_len(client->writebuf, (const gchar *) buffer, (gssize) count);
}
@@ -226,7 +223,7 @@ net_client_siobuf_printf(NetClientSioBuf *client, const gchar *format, ...)
g_return_if_fail(NET_IS_CLIENT_SIOBUF(client) && (format != NULL));
va_start(args, format);
- g_string_append_vprintf(client->priv->writebuf, format, args);
+ g_string_append_vprintf(client->writebuf, format, args);
va_end(args);
}
@@ -234,16 +231,14 @@ net_client_siobuf_printf(NetClientSioBuf *client, const gchar *format, ...)
gboolean
net_client_siobuf_flush(NetClientSioBuf *client, GError **error)
{
- const NetClientSioBufPrivate *priv;
gboolean result;
g_return_val_if_fail(NET_IS_CLIENT_SIOBUF(client), FALSE);
- priv = client->priv;
- if (priv->writebuf->len > 0U) {
- (void) g_string_append(priv->writebuf, "\r\n");
- result = net_client_write_buffer(NET_CLIENT(client), priv->writebuf->str,
priv->writebuf->len, error);
- (void) g_string_truncate(priv->writebuf, 0U);
+ if (client->writebuf->len > 0U) {
+ (void) g_string_append(client->writebuf, "\r\n");
+ result = net_client_write_buffer(NET_CLIENT(client), client->writebuf->str,
client->writebuf->len, error);
+ (void) g_string_truncate(client->writebuf, 0U);
} else {
result = FALSE;
}
@@ -263,27 +258,26 @@ net_client_siobuf_class_init(NetClientSioBufClass *klass)
}
+/*lint -e{715,818} */
static void
-net_client_siobuf_init(NetClientSioBuf *self)
+net_client_siobuf_init(G_GNUC_UNUSED NetClientSioBuf *self)
{
- self->priv = net_client_siobuf_get_instance_private(self);
}
static gboolean
net_client_siobuf_fill(NetClientSioBuf *client, GError **error)
{
- NetClientSioBufPrivate *priv = client->priv;
gboolean result;
- if ((priv->buffer->len == 0U) || (priv->read_ptr == NULL) || (*priv->read_ptr == '\0')) {
+ if ((client->buffer->len == 0U) || (client->read_ptr == NULL) || (*client->read_ptr == '\0')) {
gchar *read_buf;
result = net_client_read_line(NET_CLIENT(client), &read_buf, error);
if (result) {
- (void) g_string_assign(priv->buffer, read_buf);
- (void) g_string_append(priv->buffer, "\r\n");
- priv->read_ptr = priv->buffer->str;
+ (void) g_string_assign(client->buffer, read_buf);
+ (void) g_string_append(client->buffer, "\r\n");
+ client->read_ptr = client->buffer->str;
g_free(read_buf);
}
} else {
@@ -300,7 +294,7 @@ net_client_siobuf_finalise(GObject *object)
const NetClientSioBuf *client = NET_CLIENT_SIOBUF(object);
const GObjectClass *parent_class = G_OBJECT_CLASS(net_client_siobuf_parent_class);
- (void) g_string_free(client->priv->buffer, TRUE);
- (void) g_string_free(client->priv->writebuf, TRUE);
+ (void) g_string_free(client->buffer, TRUE);
+ (void) g_string_free(client->writebuf, TRUE);
(*parent_class->finalize)(object);
}
diff --git a/libnetclient/net-client-siobuf.h b/libnetclient/net-client-siobuf.h
index 91af01a3a..a0ac43862 100644
--- a/libnetclient/net-client-siobuf.h
+++ b/libnetclient/net-client-siobuf.h
@@ -23,33 +23,10 @@ G_BEGIN_DECLS
#define NET_CLIENT_SIOBUF_TYPE (net_client_siobuf_get_type())
-#define NET_CLIENT_SIOBUF(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
NET_CLIENT_SIOBUF_TYPE, NetClientSioBuf))
-#define NET_IS_CLIENT_SIOBUF(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
NET_CLIENT_SIOBUF_TYPE))
-#define NET_CLIENT_SIOBUF_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), NET_CLIENT_SIOBUF_TYPE,
NetClientSioBufClass))
-#define NET_IS_CLIENT_SIOBUF_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NET_CLIENT_SIOBUF_TYPE))
-#define NET_CLIENT_SIOBUF_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), NET_CLIENT_SIOBUF_TYPE,
NetClientSioBufClass))
+G_DECLARE_FINAL_TYPE(NetClientSioBuf, net_client_siobuf, NET, CLIENT_SIOBUF, NetClient)
-#define NET_CLIENT_SIOBUF_ERROR_QUARK (g_quark_from_static_string("net-client-siobuf"))
-
-
-typedef struct _NetClientSioBuf NetClientSioBuf;
-typedef struct _NetClientSioBufClass NetClientSioBufClass;
-typedef struct _NetClientSioBufPrivate NetClientSioBufPrivate;
-
-
-struct _NetClientSioBuf {
- NetClient parent;
- NetClientSioBufPrivate *priv;
-};
-
-struct _NetClientSioBufClass {
- NetClientClass parent;
-};
-
-
-GType net_client_siobuf_get_type(void)
- G_GNUC_CONST;
+#define NET_CLIENT_SIOBUF_ERROR_QUARK (g_quark_from_static_string("net-client-siobuf"))
/** @brief Create a new SIOBUF network client
diff --git a/libnetclient/net-client-smtp.c b/libnetclient/net-client-smtp.c
index 63c59fa3c..f532222e3 100644
--- a/libnetclient/net-client-smtp.c
+++ b/libnetclient/net-client-smtp.c
@@ -18,7 +18,10 @@
#include "net-client-smtp.h"
-struct _NetClientSmtpPrivate {
+/*lint -esym(754,_NetClientSmtp::parent) required field, not referenced directly */
+struct _NetClientSmtp {
+ NetClient parent;
+
NetClientCryptMode crypt_mode;
guint auth_allowed[2]; /** 0: encrypted, 1: unencrypted */
gboolean can_dsn;
@@ -49,7 +52,8 @@ typedef struct {
#define SMTP_DATA_BUF_SIZE 8192U
-G_DEFINE_TYPE_WITH_PRIVATE(NetClientSmtp, net_client_smtp, NET_CLIENT_TYPE)
+/*lint -esym(528,net_client_smtp_get_instance_private) auto-generated function, not referenced */
+G_DEFINE_TYPE(NetClientSmtp, net_client_smtp, NET_CLIENT_TYPE)
static void net_client_smtp_finalise(GObject *object);
@@ -84,7 +88,7 @@ net_client_smtp_new(const gchar *host, guint16 port, NetClientCryptMode crypt_mo
g_object_unref(G_OBJECT(client));
client = NULL;
} else {
- client->priv->crypt_mode = crypt_mode;
+ client->crypt_mode = crypt_mode;
}
}
@@ -98,9 +102,9 @@ net_client_smtp_allow_auth(NetClientSmtp *client, gboolean encrypted, guint allo
/* paranoia check */
g_return_val_if_fail(NET_IS_CLIENT_SMTP(client), FALSE);
if (encrypted) {
- client->priv->auth_allowed[0] = allow_auth;
+ client->auth_allowed[0] = allow_auth;
} else {
- client->priv->auth_allowed[1] = allow_auth;
+ client->auth_allowed[1] = allow_auth;
}
return TRUE;
}
@@ -118,7 +122,7 @@ net_client_smtp_connect(NetClientSmtp *client, gchar **greeting, GError **error)
/* establish connection, and immediately switch to TLS if required */
result = net_client_connect(NET_CLIENT(client), error);
- if (result && (client->priv->crypt_mode == NET_CLIENT_CRYPT_ENCRYPTED)) {
+ if (result && (client->crypt_mode == NET_CLIENT_CRYPT_ENCRYPTED)) {
result = net_client_start_tls(NET_CLIENT(client), error);
}
@@ -135,9 +139,9 @@ net_client_smtp_connect(NetClientSmtp *client, gchar **greeting, GError **error)
/* perform STARTTLS if required, and send EHLO again */
if (result &&
- ((client->priv->crypt_mode == NET_CLIENT_CRYPT_STARTTLS) || (client->priv->crypt_mode ==
NET_CLIENT_CRYPT_STARTTLS_OPT))) {
+ ((client->crypt_mode == NET_CLIENT_CRYPT_STARTTLS) || (client->crypt_mode ==
NET_CLIENT_CRYPT_STARTTLS_OPT))) {
if (!can_starttls) {
- if (client->priv->crypt_mode == NET_CLIENT_CRYPT_STARTTLS) {
+ if (client->crypt_mode == NET_CLIENT_CRYPT_STARTTLS) {
g_set_error(error, NET_CLIENT_SMTP_ERROR_QUARK, (gint)
NET_CLIENT_ERROR_SMTP_NO_STARTTLS,
_("remote server does not support STARTTLS"));
result = FALSE;
@@ -169,7 +173,7 @@ net_client_smtp_connect(NetClientSmtp *client, gchar **greeting, GError **error)
g_debug("passwordless authentication failed, retry w/ password: emit 'auth'
signal for client %p", client);
g_clear_error(error);
g_free(auth_data);
- g_signal_emit_by_name(client, "auth", TRUE, &auth_data);
+ g_signal_emit_by_name(client, "auth", TRUE, &auth_data); /*lint !e730
passing a gboolean is intended here */
if ((auth_data != NULL) && (auth_data[0] != NULL)) {
result = net_client_smtp_auth(client, auth_data[0], auth_data[1],
auth_supported & ~NET_CLIENT_SMTP_AUTH_NO_PWD, error);
@@ -188,7 +192,7 @@ net_client_smtp_connect(NetClientSmtp *client, gchar **greeting, GError **error)
gboolean
net_client_smtp_can_dsn(NetClientSmtp *client)
{
- return NET_IS_CLIENT_SMTP(client) ? client->priv->can_dsn : FALSE;
+ return NET_IS_CLIENT_SMTP(client) ? client->can_dsn : FALSE;
}
@@ -206,7 +210,7 @@ net_client_smtp_send_msg(NetClientSmtp *client, const NetClientSmtpMessage *mess
/* set the RFC 5321 sender and recipient(s) */
netclient = NET_CLIENT(client); /* convenience pointer */
(void) net_client_set_timeout(netclient, 5U * 60U); /* RFC 5321, Sect. 4.5.3.2.2., 4.5.3.2.3.: 5
minutes timeout */
- if (client->priv->can_dsn && message->have_dsn_rcpt) {
+ if (client->can_dsn && message->have_dsn_rcpt) {
if (message->dsn_envid != NULL) {
result = net_client_smtp_execute(client, "MAIL FROM:<%s> RET=%s ENVID=%s", NULL,
error, message->sender,
(message->dsn_ret_full) ? "FULL" : "HDRS", message->dsn_envid);
@@ -242,7 +246,7 @@ net_client_smtp_send_msg(NetClientSmtp *client, const NetClientSmtpMessage *mess
gchar last_char = '\0';
(void) net_client_set_timeout(netclient, 3U * 60U); /* RFC 5321, Sect. 4.5.3.2.5.: 3
minutes timeout */
- client->priv->data_state = TRUE;
+ client->data_state = TRUE;
do {
count = message->data_callback(buffer, SMTP_DATA_BUF_SIZE, message->user_data, error);
if (count < 0) {
@@ -264,7 +268,7 @@ net_client_smtp_send_msg(NetClientSmtp *client, const NetClientSmtpMessage *mess
if (result) {
(void) net_client_set_timeout(netclient, 10U * 60U); /* RFC 5321, Sect 4.5.3.2.6.: 10
minutes timeout */
result = net_client_smtp_read_reply(client, -1, NULL, error);
- client->priv->data_state = FALSE;
+ client->data_state = FALSE;
}
return result;
@@ -335,7 +339,7 @@ net_client_smtp_msg_free(NetClientSmtpMessage *smtp_msg)
if (smtp_msg != NULL) {
g_free(smtp_msg->sender);
g_free(smtp_msg->dsn_envid);
- /*lint -e{9074} -e{9087} accept safe (and required) pointer conversion */
+ /*lint -e{9074} -e{9087} accept safe (and required) pointer conversion (MISRA C:2012
Rules 11.1, 11.3) */
g_list_free_full(smtp_msg->recipients, (GDestroyNotify) smtp_rcpt_free);
g_free(smtp_msg);
}
@@ -356,21 +360,20 @@ net_client_smtp_class_init(NetClientSmtpClass *klass)
static void
net_client_smtp_init(NetClientSmtp *self)
{
- self->priv = net_client_smtp_get_instance_private(self); /*lint !e9079 (MISRA C:2012 Rule
11.5) intended use */
- self->priv->auth_allowed[0] = NET_CLIENT_SMTP_AUTH_ALL;
- self->priv->auth_allowed[1] = NET_CLIENT_SMTP_AUTH_SAFE;
+ self->auth_allowed[0] = NET_CLIENT_SMTP_AUTH_ALL;
+ self->auth_allowed[1] = NET_CLIENT_SMTP_AUTH_SAFE;
}
static void
net_client_smtp_finalise(GObject *object)
{
- const NetClientSmtp *client = NET_CLIENT_SMTP(object);
+ NetClientSmtp *client = NET_CLIENT_SMTP(object);
const GObjectClass *parent_class = G_OBJECT_CLASS(net_client_smtp_parent_class);
/* send the 'QUIT' command unless we are in 'DATA' state where the server will probably fail to reply
- no need to evaluate the
* reply or check for errors */
- if (net_client_is_connected(NET_CLIENT(client)) && !client->priv->data_state) {
+ if (net_client_is_connected(NET_CLIENT(client)) && !client->data_state) {
(void) net_client_execute(NET_CLIENT(client), NULL, "QUIT", NULL);
}
@@ -400,9 +403,9 @@ net_client_smtp_auth(NetClientSmtp *client, const gchar *user, const gchar *pass
/* calculate the possible authentication methods */
if (net_client_is_encrypted(NET_CLIENT(client))) {
- auth_mask = client->priv->auth_allowed[0] & auth_supported;
+ auth_mask = client->auth_allowed[0] & auth_supported;
} else {
- auth_mask = client->priv->auth_allowed[1] & auth_supported;
+ auth_mask = client->auth_allowed[1] & auth_supported;
}
if (auth_mask == 0U) {
@@ -538,7 +541,7 @@ net_client_smtp_auth_gssapi(NetClientSmtp *client, const gchar *user, GError **e
#else
-/*lint -e{715} -e{818} */
+/*lint -e{715,818} */
static gboolean
net_client_smtp_auth_gssapi(NetClientSmtp G_GNUC_UNUSED *client, const gchar G_GNUC_UNUSED *user, GError
G_GNUC_UNUSED **error)
{
@@ -556,7 +559,7 @@ net_client_smtp_execute(NetClientSmtp *client, const gchar *request_fmt, gchar *
va_list args;
gboolean result;
- va_start(args, error); /*lint !e413 a NULL error argument is irrelevant here */
+ va_start(args, error);
result = net_client_vwrite_line(NET_CLIENT(client), request_fmt, args, error);
va_end(args);
@@ -578,7 +581,7 @@ net_client_smtp_ehlo(NetClientSmtp *client, guint *auth_supported, gboolean *can
/* clear all capability flags */
*auth_supported = 0U;
- client->priv->can_dsn = FALSE;
+ client->can_dsn = FALSE;
*can_starttls = FALSE;
/* evaluate the response */
@@ -598,7 +601,7 @@ net_client_smtp_ehlo(NetClientSmtp *client, guint *auth_supported, gboolean *can
result = FALSE;
} else {
if (strcmp(&endptr[1], "DSN") == 0) {
- client->priv->can_dsn = TRUE;
+ client->can_dsn = TRUE;
} else if (strcmp(&endptr[1], "STARTTLS") == 0) {
*can_starttls = TRUE;
} else if ((strncmp(&endptr[1], "AUTH ", 5U) == 0) || (strncmp(&endptr[1],
"AUTH=", 5U) == 0)) {
@@ -727,7 +730,7 @@ net_client_smtp_dsn_to_string(const NetClientSmtp *client, NetClientSmtpDsnMode
gchar *result;
/* create the RFC 3461 DSN string */
- if (client->priv->can_dsn && (dsn_mode != NET_CLIENT_SMTP_DSN_NEVER)) {
+ if (client->can_dsn && (dsn_mode != NET_CLIENT_SMTP_DSN_NEVER)) {
GString *dsn_buf;
gsize start_len;
diff --git a/libnetclient/net-client-smtp.h b/libnetclient/net-client-smtp.h
index 194fc68c4..65b62c3b4 100644
--- a/libnetclient/net-client-smtp.h
+++ b/libnetclient/net-client-smtp.h
@@ -23,18 +23,12 @@ G_BEGIN_DECLS
#define NET_CLIENT_SMTP_TYPE (net_client_smtp_get_type())
-#define NET_CLIENT_SMTP(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
NET_CLIENT_SMTP_TYPE, NetClientSmtp))
-#define NET_IS_CLIENT_SMTP(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
NET_CLIENT_SMTP_TYPE))
-#define NET_CLIENT_SMTP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), NET_CLIENT_SMTP_TYPE,
NetClientSmtpClass))
-#define NET_IS_CLIENT_SMTP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
NET_CLIENT_SMTP_TYPE))
-#define NET_CLIENT_SMTP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), NET_CLIENT_SMTP_TYPE,
NetClientSmtpClass))
+G_DECLARE_FINAL_TYPE(NetClientSmtp, net_client_smtp, NET, CLIENT_SMTP, NetClient)
+
#define NET_CLIENT_SMTP_ERROR_QUARK (g_quark_from_static_string("net-client-smtp"))
-typedef struct _NetClientSmtp NetClientSmtp;
-typedef struct _NetClientSmtpClass NetClientSmtpClass;
-typedef struct _NetClientSmtpPrivate NetClientSmtpPrivate;
typedef struct _NetClientSmtpMessage NetClientSmtpMessage;
typedef enum _NetClientSmtpDsnMode NetClientSmtpDsnMode;
@@ -75,17 +69,6 @@ enum _NetClientSmtpError {
/** @} */
-struct _NetClientSmtp {
- NetClient parent;
- NetClientSmtpPrivate *priv;
-};
-
-
-struct _NetClientSmtpClass {
- NetClientClass parent;
-};
-
-
/** @brief Delivery Status Notification mode
*
* See <a href="https://tools.ietf.org/html/rfc3461";>RFC 3461</a> for a description of Delivery Status
Notifications (DSNs). The
@@ -116,10 +99,6 @@ enum _NetClientSmtpDsnMode {
typedef gssize (*NetClientSmtpSendCb)(gchar *buffer, gsize count, gpointer user_data, GError **error);
-GType net_client_smtp_get_type(void)
- G_GNUC_CONST;
-
-
/** @brief Create a new SMTP network client
*
* @param host host name or IP address to connect
diff --git a/libnetclient/net-client-utils.h b/libnetclient/net-client-utils.h
index ab90dfea6..033f88684 100644
--- a/libnetclient/net-client-utils.h
+++ b/libnetclient/net-client-utils.h
@@ -127,6 +127,7 @@ gint net_client_gss_auth_step(NetClientGssCtx *gss_ctx, const gchar *in_token, g
*
* Create the final token which has to be sent to the remote server to finalise the GSSAPI authentication
process.
*/
+/*lint -ecall(9076,net_client_gss_auth_finish) suppress false-positive re. [const] NetClientGssCtx*
(FlexeLint 9.00L bug) */
gchar *net_client_gss_auth_finish(const NetClientGssCtx *gss_ctx, const gchar *in_token, GError **error)
G_GNUC_WARN_UNUSED_RESULT;
diff --git a/libnetclient/net-client.c b/libnetclient/net-client.c
index f9e023351..f3f1b3d12 100644
--- a/libnetclient/net-client.c
+++ b/libnetclient/net-client.c
@@ -35,6 +35,8 @@
* GIOStream *tls_conn -- optional
* GOutputStream *ostream -- optionally compressed
*/
+typedef struct _NetClientPrivate NetClientPrivate;
+
struct _NetClientPrivate {
gchar *host_and_port;
guint16 default_port;
@@ -67,18 +69,21 @@ NetClient *
net_client_new(const gchar *host_and_port, guint16 default_port, gsize max_line_len)
{
NetClient *client;
+ NetClientPrivate *priv;
g_return_val_if_fail(host_and_port != NULL, NULL);
client = NET_CLIENT(g_object_new(NET_CLIENT_TYPE, NULL));
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ priv = net_client_get_instance_private(client);
- if (client->priv->sock == NULL) {
+ if (priv->sock == NULL) {
g_object_unref(G_OBJECT(client));
client = NULL;
} else {
- client->priv->host_and_port = g_strdup(host_and_port);
- client->priv->default_port = default_port;
- client->priv->max_line_len = max_line_len;
+ priv->host_and_port = g_strdup(host_and_port);
+ priv->default_port = default_port;
+ priv->max_line_len = max_line_len;
}
return client;
@@ -88,12 +93,12 @@ net_client_new(const gchar *host_and_port, guint16 default_port, gsize max_line_
gboolean
net_client_configure(NetClient *client, const gchar *host_and_port, guint16 default_port, gsize
max_line_len, GError **error)
{
- NetClientPrivate *priv;
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ NetClientPrivate *priv = net_client_get_instance_private(client);
gboolean result;
g_return_val_if_fail(NET_IS_CLIENT(client) && (host_and_port != NULL), FALSE);
- priv = client->priv;
if (priv->plain_conn != NULL) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_CONNECTED, _("network
client is already connected"));
result = FALSE;
@@ -109,13 +114,16 @@ net_client_configure(NetClient *client, const gchar *host_and_port, guint16 defa
const gchar *
-net_client_get_host(const NetClient *client)
+net_client_get_host(NetClient *client)
{
const gchar *result;
- /*lint -e{9005} cast'ing away const in the next statement is fine */
if (NET_IS_CLIENT(client)) {
- result = client->priv->host_and_port;
+ const NetClientPrivate *priv;
+
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ priv = net_client_get_instance_private(client);
+ result = priv->host_and_port;
} else {
result = NULL;
}
@@ -127,11 +135,11 @@ gboolean
net_client_connect(NetClient *client, GError **error)
{
gboolean result = FALSE;
- NetClientPrivate *priv;
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ NetClientPrivate *priv = net_client_get_instance_private(client);
g_return_val_if_fail(NET_IS_CLIENT(client), FALSE);
- priv = client->priv;
if (priv->plain_conn != NULL) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_CONNECTED, _("network
client is already connected"));
} else {
@@ -150,41 +158,46 @@ net_client_connect(NetClient *client, GError **error)
void
-net_client_shutdown(const NetClient *client)
+net_client_shutdown(NetClient *client)
{
if (NET_IS_CLIENT(client)) {
+ NetClientPrivate *priv;
+
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ priv = net_client_get_instance_private(client);
+
/* Note: we must unref the GDataInputStream, but the GOutputStream only if compression is
active! */
- if (client->priv->comp != NULL) {
+ if (priv->comp != NULL) {
/* Note: for some strange reason, GIO decides to send a 0x03 0x00 sequence when
closing a compressed connection, before
* sending the usual FIN, ACK TCP reply packet. As the remote server does not expect
the former (the connection has
* already been closed on its side), it replies with with a RST TCP packet.
Unref'ing client->priv->ostream and
* client->priv->comp /after/ all other components of the connection fixes the issue
for unencrypted connections, but
* throws a critical error for TLS. Observed with gio 2.48.2 and 2.50.3, no idea how
it can be fixed.
* See also https://bugzilla.gnome.org/show_bug.cgi?id=795985. */
- if (client->priv->ostream != NULL) {
- g_object_unref(G_OBJECT(client->priv->ostream));
+ if (priv->ostream != NULL) {
+ g_object_unref(G_OBJECT(priv->ostream));
}
- g_object_unref(G_OBJECT(client->priv->comp));
+ g_object_unref(G_OBJECT(priv->comp));
}
- if (client->priv->decomp != NULL) {
- g_object_unref(G_OBJECT(client->priv->decomp));
- client->priv->decomp = NULL;
+ if (priv->decomp != NULL) {
+ g_object_unref(G_OBJECT(priv->decomp));
+ priv->decomp = NULL;
}
- if (client->priv->comp_istream!= NULL) {
- g_object_unref(G_OBJECT(client->priv->comp_istream));
- client->priv->comp_istream = NULL;
+ if (priv->comp_istream!= NULL) {
+ g_object_unref(G_OBJECT(priv->comp_istream));
+ priv->comp_istream = NULL;
}
- if (client->priv->istream != NULL) {
- g_object_unref(G_OBJECT(client->priv->istream));
- client->priv->istream = NULL;
+ if (priv->istream != NULL) {
+ g_object_unref(G_OBJECT(priv->istream));
+ priv->istream = NULL;
}
- if (client->priv->tls_conn != NULL) {
- g_object_unref(G_OBJECT(client->priv->tls_conn));
- client->priv->tls_conn = NULL;
+ if (priv->tls_conn != NULL) {
+ g_object_unref(G_OBJECT(priv->tls_conn));
+ priv->tls_conn = NULL;
}
- if (client->priv->plain_conn != NULL) {
- g_object_unref(G_OBJECT(client->priv->plain_conn));
- client->priv->plain_conn = NULL;
+ if (priv->plain_conn != NULL) {
+ g_object_unref(G_OBJECT(priv->plain_conn));
+ priv->plain_conn = NULL;
}
}
}
@@ -195,8 +208,12 @@ net_client_is_connected(NetClient *client)
{
gboolean result;
- if (NET_IS_CLIENT(client) && (client->priv->plain_conn != NULL)) {
- result = TRUE;
+ if (NET_IS_CLIENT(client)) {
+ const NetClientPrivate *priv;
+
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ priv = net_client_get_instance_private(client);
+ result = (priv->plain_conn != NULL);
} else {
result = FALSE;
}
@@ -210,8 +227,12 @@ net_client_is_encrypted(NetClient *client)
{
gboolean result;
- if (net_client_is_connected(client) && (client->priv->tls_conn != NULL)) {
- result = TRUE;
+ if (net_client_is_connected(client)) {
+ const NetClientPrivate *priv;
+
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ priv = net_client_get_instance_private(client);
+ result = (priv->tls_conn != NULL);
} else {
result = FALSE;
}
@@ -223,24 +244,26 @@ net_client_is_encrypted(NetClient *client)
gboolean
net_client_read_line(NetClient *client, gchar **recv_line, GError **error)
{
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ const NetClientPrivate *priv = net_client_get_instance_private(client);
gboolean result = FALSE;
g_return_val_if_fail(NET_IS_CLIENT(client), FALSE);
- if (client->priv->istream == NULL) {
+ if (priv->istream == NULL) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_NOT_CONNECTED, _("network
client is not connected"));
} else {
gchar *line_buf;
gsize length;
GError *read_err = NULL;
- line_buf = g_data_input_stream_read_line(client->priv->istream, &length, NULL, &read_err);
+ line_buf = g_data_input_stream_read_line(priv->istream, &length, NULL, &read_err);
if (line_buf != NULL) {
/* check that the protocol-specific maximum line length is not exceeded */
- if ((client->priv->max_line_len > 0U) && (length > client->priv->max_line_len)) {
+ if ((priv->max_line_len > 0U) && (length > priv->max_line_len)) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint)
NET_CLIENT_ERROR_LINE_TOO_LONG,
_("reply length %lu exceeds the maximum allowed length %lu"),
- (unsigned long) length, (unsigned long) client->priv->max_line_len);
+ (unsigned long) length, (unsigned long) priv->max_line_len);
g_free(line_buf);
} else {
g_debug("R '%s'", line_buf);
@@ -267,11 +290,13 @@ net_client_read_line(NetClient *client, gchar **recv_line, GError **error)
gboolean
net_client_write_buffer(NetClient *client, const gchar *buffer, gsize count, GError **error)
{
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ const NetClientPrivate *priv = net_client_get_instance_private(client);
gboolean result;
g_return_val_if_fail(NET_IS_CLIENT(client) && (buffer != NULL) && (count > 0UL), FALSE);
- if (client->priv->ostream == NULL) {
+ if (priv->ostream == NULL) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_NOT_CONNECTED, _("network
client is not connected"));
result = FALSE;
} else {
@@ -282,9 +307,9 @@ net_client_write_buffer(NetClient *client, const gchar *buffer, gsize count, GEr
} else {
g_debug("W '%.*s'", (int) count, buffer);
}
- result = g_output_stream_write_all(client->priv->ostream, buffer, count, &bytes_written,
NULL, error);
+ result = g_output_stream_write_all(priv->ostream, buffer, count, &bytes_written, NULL, error);
if (result) {
- result = g_output_stream_flush(client->priv->ostream, NULL, error);
+ result = g_output_stream_flush(priv->ostream, NULL, error);
}
}
@@ -295,6 +320,8 @@ net_client_write_buffer(NetClient *client, const gchar *buffer, gsize count, GEr
gboolean
net_client_vwrite_line(NetClient *client, const gchar *format, va_list args, GError **error)
{
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ const NetClientPrivate *priv = net_client_get_instance_private(client);
gboolean result;
GString *buffer;
@@ -302,7 +329,7 @@ net_client_vwrite_line(NetClient *client, const gchar *format, va_list args, GEr
buffer = g_string_new(NULL);
g_string_vprintf(buffer, format, args);
- if ((client->priv->max_line_len > 0U) && (buffer->len > client->priv->max_line_len)) {
+ if ((priv->max_line_len > 0U) && (buffer->len > priv->max_line_len)) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_LINE_TOO_LONG, _("line too
long"));
result = FALSE;
} else {
@@ -357,6 +384,8 @@ net_client_execute(NetClient *client, gchar **response, const gchar *request_fmt
gboolean
net_client_set_cert_from_pem(NetClient *client, const gchar *pem_data, GError **error)
{
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ NetClientPrivate *priv = net_client_get_instance_private(client);
gboolean result = FALSE;
gnutls_x509_crt_t cert;
int res;
@@ -364,9 +393,9 @@ net_client_set_cert_from_pem(NetClient *client, const gchar *pem_data, GError **
g_return_val_if_fail(NET_IS_CLIENT(client) && (pem_data != NULL), FALSE);
/* always free any existing certificate */
- if (client->priv->certificate != NULL) {
- g_object_unref(G_OBJECT(client->priv->certificate));
- client->priv->certificate = NULL;
+ if (priv->certificate != NULL) {
+ g_object_unref(G_OBJECT(priv->certificate));
+ priv->certificate = NULL;
}
/* load the certificate */
@@ -440,8 +469,8 @@ net_client_set_cert_from_pem(NetClient *client, const gchar *pem_data, GError **
}
if (res == GNUTLS_E_SUCCESS) {
- client->priv->certificate =
g_tls_certificate_new_from_pem(pem_buf, -1, error);
- if (client->priv->certificate != NULL) {
+ priv->certificate = g_tls_certificate_new_from_pem(pem_buf,
-1, error);
+ if (priv->certificate != NULL) {
result = TRUE;
}
}
@@ -485,32 +514,34 @@ net_client_set_cert_from_file(NetClient *client, const gchar *pem_path, GError *
gboolean
net_client_start_tls(NetClient *client, GError **error)
{
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ NetClientPrivate *priv = net_client_get_instance_private(client);
gboolean result = FALSE;
g_return_val_if_fail(NET_IS_CLIENT(client), FALSE);
- if (client->priv->plain_conn == NULL) {
+ if (priv->plain_conn == NULL) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_NOT_CONNECTED, _("not
connected"));
- } else if (client->priv->tls_conn != NULL) {
+ } else if (priv->tls_conn != NULL) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_TLS_ACTIVE, _("connection
is already encrypted"));
} else {
- client->priv->tls_conn = g_tls_client_connection_new(G_IO_STREAM(client->priv->plain_conn),
NULL, error);
- if (client->priv->tls_conn != NULL) {
- if (client->priv->certificate != NULL) {
- g_tls_connection_set_certificate(G_TLS_CONNECTION(client->priv->tls_conn),
client->priv->certificate);
+ priv->tls_conn = g_tls_client_connection_new(G_IO_STREAM(priv->plain_conn), NULL, error);
+ if (priv->tls_conn != NULL) {
+ if (priv->certificate != NULL) {
+ g_tls_connection_set_certificate(G_TLS_CONNECTION(priv->tls_conn),
priv->certificate);
}
- (void) g_signal_connect(G_OBJECT(client->priv->tls_conn), "accept-certificate",
G_CALLBACK(cert_accept_cb), client);
- result = g_tls_connection_handshake(G_TLS_CONNECTION(client->priv->tls_conn), NULL,
error);
+ (void) g_signal_connect(G_OBJECT(priv->tls_conn), "accept-certificate",
G_CALLBACK(cert_accept_cb), client);
+ result = g_tls_connection_handshake(G_TLS_CONNECTION(priv->tls_conn), NULL, error);
if (result) {
-
g_filter_input_stream_set_close_base_stream(G_FILTER_INPUT_STREAM(client->priv->istream), FALSE);
- g_object_unref(G_OBJECT(client->priv->istream)); /* unref the
plain connection's stream */
- client->priv->istream =
g_data_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(client->priv->tls_conn)));
- g_data_input_stream_set_newline_type(client->priv->istream,
G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
- client->priv->ostream =
g_io_stream_get_output_stream(G_IO_STREAM(client->priv->tls_conn));
+
g_filter_input_stream_set_close_base_stream(G_FILTER_INPUT_STREAM(priv->istream), FALSE);
+ g_object_unref(G_OBJECT(priv->istream)); /* unref the plain
connection's stream */
+ priv->istream =
g_data_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(priv->tls_conn)));
+ g_data_input_stream_set_newline_type(priv->istream,
G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
+ priv->ostream = g_io_stream_get_output_stream(G_IO_STREAM(priv->tls_conn));
g_debug("connection is encrypted");
} else {
- g_object_unref(G_OBJECT(client->priv->tls_conn));
- client->priv->tls_conn = NULL;
+ g_object_unref(G_OBJECT(priv->tls_conn));
+ priv->tls_conn = NULL;
}
}
}
@@ -522,34 +553,36 @@ net_client_start_tls(NetClient *client, GError **error)
gboolean
net_client_start_compression(NetClient *client, GError **error)
{
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ NetClientPrivate *priv = net_client_get_instance_private(client);
gboolean result = FALSE;
g_return_val_if_fail(NET_IS_CLIENT(client), FALSE);
- if (client->priv->plain_conn == NULL) {
+ if (priv->plain_conn == NULL) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_NOT_CONNECTED, _("not
connected"));
- } else if (client->priv->comp != NULL) {
+ } else if (priv->comp != NULL) {
g_set_error(error, NET_CLIENT_ERROR_QUARK, (gint) NET_CLIENT_ERROR_COMP_ACTIVE, _("connection
is already compressed"));
} else {
- client->priv->comp = g_zlib_compressor_new(G_ZLIB_COMPRESSOR_FORMAT_RAW, -1);
- client->priv->decomp = g_zlib_decompressor_new(G_ZLIB_COMPRESSOR_FORMAT_RAW);
+ priv->comp = g_zlib_compressor_new(G_ZLIB_COMPRESSOR_FORMAT_RAW, -1);
+ priv->decomp = g_zlib_decompressor_new(G_ZLIB_COMPRESSOR_FORMAT_RAW);
- g_filter_input_stream_set_close_base_stream(G_FILTER_INPUT_STREAM(client->priv->istream),
FALSE);
- g_object_unref(client->priv->istream);
+ g_filter_input_stream_set_close_base_stream(G_FILTER_INPUT_STREAM(priv->istream), FALSE);
+ g_object_unref(priv->istream);
- if (client->priv->tls_conn != NULL) {
- client->priv->comp_istream =
-
g_converter_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(client->priv->tls_conn)),
- G_CONVERTER(client->priv->decomp));
+ if (priv->tls_conn != NULL) {
+ priv->comp_istream =
+
g_converter_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(priv->tls_conn)),
+ G_CONVERTER(priv->decomp));
} else {
- client->priv->comp_istream =
-
g_converter_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(client->priv->plain_conn)),
- G_CONVERTER(client->priv->decomp));
+ priv->comp_istream =
+
g_converter_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(priv->plain_conn)),
+ G_CONVERTER(priv->decomp));
}
- client->priv->istream = g_data_input_stream_new(client->priv->comp_istream);
- g_data_input_stream_set_newline_type(client->priv->istream, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
+ priv->istream = g_data_input_stream_new(priv->comp_istream);
+ g_data_input_stream_set_newline_type(priv->istream, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
- client->priv->ostream = g_converter_output_stream_new(client->priv->ostream,
G_CONVERTER(client->priv->comp));
+ priv->ostream = g_converter_output_stream_new(priv->ostream, G_CONVERTER(priv->comp));
result = TRUE;
g_debug("connection is compressed");
}
@@ -561,9 +594,12 @@ net_client_start_compression(NetClient *client, GError **error)
gboolean
net_client_set_timeout(NetClient *client, guint timeout_secs)
{
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ const NetClientPrivate *priv = net_client_get_instance_private(client);
+
g_return_val_if_fail(NET_IS_CLIENT(client), FALSE);
- g_socket_client_set_timeout(client->priv->sock, timeout_secs);
+ g_socket_client_set_timeout(priv->sock, timeout_secs);
return TRUE;
}
@@ -571,19 +607,25 @@ net_client_set_timeout(NetClient *client, guint timeout_secs)
GSocket *
net_client_get_socket(NetClient *client)
{
- g_return_val_if_fail(NET_IS_CLIENT(client) && (client->priv->plain_conn != NULL), NULL);
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ const NetClientPrivate *priv = net_client_get_instance_private(client);
+
+ g_return_val_if_fail(NET_IS_CLIENT(client) && (priv->plain_conn != NULL), NULL);
- return g_socket_connection_get_socket(client->priv->plain_conn);
+ return g_socket_connection_get_socket(priv->plain_conn);
}
gboolean
net_client_can_read(NetClient *client)
{
- g_return_val_if_fail(NET_IS_CLIENT(client) && (client->priv->plain_conn != NULL) &&
(client->priv->istream != NULL), FALSE);
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ const NetClientPrivate *priv = net_client_get_instance_private(client);
- return (g_socket_condition_check(g_socket_connection_get_socket(client->priv->plain_conn), G_IO_IN)
!= 0) ||
- (g_buffered_input_stream_get_available(G_BUFFERED_INPUT_STREAM(client->priv->istream)) > 0U);
+ g_return_val_if_fail(NET_IS_CLIENT(client) && (priv->plain_conn != NULL) && (priv->istream != NULL),
FALSE);
+
+ return (g_socket_condition_check(g_socket_connection_get_socket(priv->plain_conn), G_IO_IN) != 0) ||
+ (g_buffered_input_stream_get_available(G_BUFFERED_INPUT_STREAM(priv->istream)) > 0U);
}
@@ -606,10 +648,12 @@ net_client_class_init(NetClientClass *klass)
static void
net_client_init(NetClient *self)
{
- self->priv = net_client_get_instance_private(self); /*lint !e9079 (MISRA C:2012 Rule
11.5) intended use of this function */
- self->priv->sock = g_socket_client_new();
- if (self->priv->sock != NULL) {
- g_socket_client_set_timeout(self->priv->sock, 180U);
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ NetClientPrivate *priv = net_client_get_instance_private(self);
+
+ priv->sock = g_socket_client_new();
+ if (priv->sock != NULL) {
+ g_socket_client_set_timeout(priv->sock, 180U);
}
}
@@ -617,24 +661,27 @@ net_client_init(NetClient *self)
static void
net_client_finalise(GObject *object)
{
- const NetClient *client = NET_CLIENT(object);
+ NetClient *client = NET_CLIENT(object);
+ /*lint -e{9079} (MISRA C:2012 Rule 11.5) intended use of this function */
+ NetClientPrivate *priv = net_client_get_instance_private(client);
const GObjectClass *parent_class = G_OBJECT_CLASS(net_client_parent_class);
net_client_shutdown(client);
- if (client->priv->sock != NULL) {
- g_object_unref(G_OBJECT(client->priv->sock));
- client->priv->sock = NULL;
+ if (priv->sock != NULL) {
+ g_object_unref(G_OBJECT(priv->sock));
+ priv->sock = NULL;
}
- if (client->priv->certificate != NULL) {
- g_object_unref(G_OBJECT(client->priv->certificate));
- client->priv->certificate = NULL;
+ if (priv->certificate != NULL) {
+ g_object_unref(G_OBJECT(priv->certificate));
+ priv->certificate = NULL;
}
- g_debug("finalised connection to %s", client->priv->host_and_port);
- g_free(client->priv->host_and_port);
+ g_debug("finalised connection to %s", priv->host_and_port);
+ g_free(priv->host_and_port);
(*parent_class->finalize)(object);
}
+/*lint -e{715,818} */
static gboolean
cert_accept_cb(G_GNUC_UNUSED GTlsConnection *conn, GTlsCertificate *peer_cert, GTlsCertificateFlags errors,
gpointer user_data)
{
diff --git a/libnetclient/net-client.h b/libnetclient/net-client.h
index ad553e440..8b1c74846 100644
--- a/libnetclient/net-client.h
+++ b/libnetclient/net-client.h
@@ -25,26 +25,10 @@ G_BEGIN_DECLS
#define NET_CLIENT_TYPE (net_client_get_type())
-#define NET_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
NET_CLIENT_TYPE, NetClient))
-#define NET_IS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
NET_CLIENT_TYPE))
-#define NET_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
NET_CLIENT_TYPE, NetClientClass))
-#define NET_IS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NET_CLIENT_TYPE))
-#define NET_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), NET_CLIENT_TYPE,
NetClientClass))
-
-#define NET_CLIENT_ERROR_QUARK (g_quark_from_static_string("net-client"))
+G_DECLARE_DERIVABLE_TYPE(NetClient, net_client, NET, CLIENT, GObject)
-typedef struct _NetClient NetClient;
-typedef struct _NetClientClass NetClientClass;
-typedef struct _NetClientPrivate NetClientPrivate;
-typedef enum _NetClientError NetClientError;
-typedef enum _NetClientCryptMode NetClientCryptMode;
-
-
-struct _NetClient {
- GObject parent;
- NetClientPrivate *priv;
-};
+#define NET_CLIENT_ERROR_QUARK (g_quark_from_static_string("net-client"))
struct _NetClientClass {
@@ -52,6 +36,10 @@ struct _NetClientClass {
};
+typedef enum _NetClientError NetClientError;
+typedef enum _NetClientCryptMode NetClientCryptMode;
+
+
/** @brief Encryption mode */
enum _NetClientCryptMode {
NET_CLIENT_CRYPT_ENCRYPTED = 1, /**< TLS encryption @em before starting the protocol
required (e.g. SMTPS). */
@@ -75,10 +63,6 @@ enum _NetClientError {
};
-GType net_client_get_type(void)
- G_GNUC_CONST;
-
-
/** @brief Create a new network client
*
* @param host_and_port remote host and port or service, separated by a colon, which shall be connected
@@ -115,7 +99,7 @@ gboolean net_client_configure(NetClient *client, const gchar *host_and_port, gui
*
* @note The function returns the value of @em host_and_port set by net_client_new() or
net_client_configure().
*/
-const gchar *net_client_get_host(const NetClient *client);
+const gchar *net_client_get_host(NetClient *client);
/** @brief Connect a network client
@@ -136,7 +120,7 @@ gboolean net_client_connect(NetClient *client, GError **error);
* Shut down the connection. Note that it is usually not necessary to call this function, as the connection
will be shut down when
* the client is destroyed by calling <tt>g_object_unref()</tt>.
*/
-void net_client_shutdown(const NetClient *client);
+void net_client_shutdown(NetClient *client);
/** @brief Check if a network client is connected
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
