devs/libstrophe-gh
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

make logging functions private

Browse Source 
Fixes #189

Signed-off-by: Steffen Jaeckel <jaeckel-floss@eyet-services.de>
This commit is contained in:
Steffen Jaeckel
2022-02-01 13:26:52 +01:00
parent a97714da18
commit 93e04b8d03
13 changed files with 240 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
src/auth.c
View File

@@ -194,7 +194,7 @@ static int _handle_missing_features(xmpp_conn_t *conn, void *userdata)
{
UNUSED(userdata);
xmpp_debug(conn->ctx, "xmpp", "didn't get stream features");
strophe_debug(conn->ctx, "xmpp", "didn't get stream features");
/* legacy auth will be attempted */
_auth(conn);
@@ -294,10 +294,10 @@ static int _handle_proceedtls_default(xmpp_conn_t *conn,
UNUSED(userdata);
name = xmpp_stanza_get_name(stanza);
xmpp_debug(conn->ctx, "xmpp", "handle proceedtls called for %s", name);
strophe_debug(conn->ctx, "xmpp", "handle proceedtls called for %s", name);
if (strcmp(name, "proceed") == 0) {
xmpp_debug(conn->ctx, "xmpp", "proceeding with TLS");
strophe_debug(conn->ctx, "xmpp", "proceeding with TLS");
if (conn_tls_start(conn) == 0) {
conn_prepare_reset(conn, _handle_open_tls);
@@ -320,14 +320,15 @@ _handle_sasl_result(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
/* the server should send a <success> or <failure> stanza */
if (strcmp(name, "failure") == 0) {
xmpp_debug(conn->ctx, "xmpp", "SASL %s auth failed", (char *)userdata);
strophe_debug(conn->ctx, "xmpp", "SASL %s auth failed",
(char *)userdata);
/* fall back to next auth method */
_auth(conn);
} else if (strcmp(name, "success") == 0) {
/* SASL auth successful, we need to restart the stream */
xmpp_debug(conn->ctx, "xmpp", "SASL %s auth successful",
(char *)userdata);
strophe_debug(conn->ctx, "xmpp", "SASL %s auth successful",
(char *)userdata);
/* reset parser */
conn_prepare_reset(conn, _handle_open_sasl);
@@ -336,9 +337,9 @@ _handle_sasl_result(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
conn_open_stream(conn);
} else {
/* got unexpected reply */
xmpp_error(conn->ctx, "xmpp",
"Got unexpected reply to SASL %s authentication.",
(char *)userdata);
strophe_error(conn->ctx, "xmpp",
"Got unexpected reply to SASL %s authentication.",
(char *)userdata);
xmpp_disconnect(conn);
}
@@ -358,8 +359,8 @@ static int _handle_digestmd5_challenge(xmpp_conn_t *conn,
UNUSED(userdata);
name = xmpp_stanza_get_name(stanza);
xmpp_debug(conn->ctx, "xmpp", "handle digest-md5 (challenge) called for %s",
name);
strophe_debug(conn->ctx, "xmpp",
"handle digest-md5 (challenge) called for %s", name);
if (strcmp(name, "challenge") == 0) {
text = xmpp_stanza_get_text(stanza);
@@ -415,8 +416,8 @@ static int _handle_digestmd5_rspauth(xmpp_conn_t *conn,
UNUSED(userdata);
name = xmpp_stanza_get_name(stanza);
xmpp_debug(conn->ctx, "xmpp", "handle digest-md5 (rspauth) called for %s",
name);
strophe_debug(conn->ctx, "xmpp",
"handle digest-md5 (rspauth) called for %s", name);
if (strcmp(name, "challenge") == 0) {
/* assume it's an rspauth response */
@@ -456,8 +457,8 @@ static int _handle_scram_challenge(xmpp_conn_t *conn,
int rc;
name = xmpp_stanza_get_name(stanza);
xmpp_debug(conn->ctx, "xmpp", "handle %s (challenge) called for %s",
scram_ctx->alg->scram_name, name);
strophe_debug(conn->ctx, "xmpp", "handle %s (challenge) called for %s",
scram_ctx->alg->scram_name, name);
if (strcmp(name, "challenge") == 0) {
text = xmpp_stanza_get_text(stanza);
@@ -630,9 +631,9 @@ static void _auth(xmpp_conn_t *conn)
}
if (conn->tls_mandatory && !xmpp_conn_is_secured(conn)) {
xmpp_error(conn->ctx, "xmpp",
"TLS is not supported, but set as "
"mandatory for this connection");
strophe_error(conn->ctx, "xmpp",
"TLS is not supported, but set as "
"mandatory for this connection");
conn_disconnect(conn);
return;
}
@@ -697,12 +698,13 @@ static void _auth(xmpp_conn_t *conn)
/* SASL EXTERNAL was tried, unset flag */
conn->sasl_support &= ~SASL_MASK_EXTERNAL;
} else if (anonjid) {
xmpp_error(conn->ctx, "auth",
"No node in JID, and SASL ANONYMOUS unsupported.");
strophe_error(conn->ctx, "auth",
"No node in JID, and SASL ANONYMOUS unsupported.");
xmpp_disconnect(conn);
} else if (conn->pass == NULL) {
xmpp_error(conn->ctx, "auth",
"Password hasn't been set, and SASL ANONYMOUS unsupported.");
strophe_error(
conn->ctx, "auth",
"Password hasn't been set, and SASL ANONYMOUS unsupported.");
xmpp_disconnect(conn);
} else if (conn->sasl_support & SASL_MASK_SCRAM) {
scram_ctx = strophe_alloc(conn->ctx, sizeof(*scram_ctx));
@@ -815,7 +817,8 @@ static void _auth(xmpp_conn_t *conn)
/* legacy client authentication */
_auth_legacy(conn);
} else {
xmpp_error(conn->ctx, "auth", "Cannot authenticate with known methods");
strophe_error(conn->ctx, "auth",
"Cannot authenticate with known methods");
xmpp_disconnect(conn);
}
}
@@ -856,7 +859,7 @@ static void _handle_open_tls(xmpp_conn_t *conn)
/* called when stream:stream tag received after SASL auth */
static void _handle_open_sasl(xmpp_conn_t *conn)
{
xmpp_debug(conn->ctx, "xmpp", "Reopened stream successfully.");
strophe_debug(conn->ctx, "xmpp", "Reopened stream successfully.");
/* setup stream:features handlers */
handler_add(conn, _handle_features_sasl, XMPP_NS_STREAMS, "features", NULL,
@@ -962,9 +965,9 @@ _handle_features_sasl(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
xmpp_stanza_release(iq);
} else {
/* can't bind, disconnect */
xmpp_error(conn->ctx, "xmpp",
"Stream features does not allow "
"resource bind.");
strophe_error(conn->ctx, "xmpp",
"Stream features does not allow "
"resource bind.");
xmpp_disconnect(conn);
}
@@ -975,9 +978,9 @@ static int _handle_missing_features_sasl(xmpp_conn_t *conn, void *userdata)
{
UNUSED(userdata);
xmpp_error(conn->ctx, "xmpp",
"Did not receive stream features "
"after SASL authentication.");
strophe_error(conn->ctx, "xmpp",
"Did not receive stream features "
"after SASL authentication.");
xmpp_disconnect(conn);
return 0;
}
@@ -996,11 +999,11 @@ _handle_bind(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
/* server has replied to bind request */
type = xmpp_stanza_get_type(stanza);
if (type && strcmp(type, "error") == 0) {
xmpp_error(conn->ctx, "xmpp", "Binding failed.");
strophe_error(conn->ctx, "xmpp", "Binding failed.");
xmpp_disconnect(conn);
} else if (type && strcmp(type, "result") == 0) {
xmpp_stanza_t *binding = xmpp_stanza_get_child_by_name(stanza, "bind");
xmpp_debug(conn->ctx, "xmpp", "Bind successful.");
strophe_debug(conn->ctx, "xmpp", "Bind successful.");
if (binding) {
xmpp_stanza_t *jid_stanza =
@@ -1048,7 +1051,7 @@ _handle_bind(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
conn->userdata);
}
} else {
xmpp_error(conn->ctx, "xmpp", "Server sent malformed bind reply.");
strophe_error(conn->ctx, "xmpp", "Server sent malformed bind reply.");
xmpp_disconnect(conn);
}
@@ -1059,7 +1062,7 @@ static int _handle_missing_bind(xmpp_conn_t *conn, void *userdata)
{
UNUSED(userdata);
xmpp_error(conn->ctx, "xmpp", "Server did not reply to bind request.");
strophe_error(conn->ctx, "xmpp", "Server did not reply to bind request.");
xmpp_disconnect(conn);
return 0;
}
@@ -1077,17 +1080,18 @@ _handle_session(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
/* server has replied to the session request */
type = xmpp_stanza_get_type(stanza);
if (type && strcmp(type, "error") == 0) {
xmpp_error(conn->ctx, "xmpp", "Session establishment failed.");
strophe_error(conn->ctx, "xmpp", "Session establishment failed.");
xmpp_disconnect(conn);
} else if (type && strcmp(type, "result") == 0) {
xmpp_debug(conn->ctx, "xmpp", "Session establishment successful.");
strophe_debug(conn->ctx, "xmpp", "Session establishment successful.");
conn->authenticated = 1;
/* call connection handler */
conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
} else {
xmpp_error(conn->ctx, "xmpp", "Server sent malformed session reply.");
strophe_error(conn->ctx, "xmpp",
"Server sent malformed session reply.");
xmpp_disconnect(conn);
}
@@ -1098,7 +1102,8 @@ static int _handle_missing_session(xmpp_conn_t *conn, void *userdata)
{
UNUSED(userdata);
xmpp_error(conn->ctx, "xmpp", "Server did not reply to session request.");
strophe_error(conn->ctx, "xmpp",
"Server did not reply to session request.");
xmpp_disconnect(conn);
return 0;
}
@@ -1107,9 +1112,9 @@ static int _handle_missing_legacy(xmpp_conn_t *conn, void *userdata)
{
UNUSED(userdata);
xmpp_error(conn->ctx, "xmpp",
"Server did not reply to legacy "
"authentication request.");
strophe_error(conn->ctx, "xmpp",
"Server did not reply to legacy "
"authentication request.");
xmpp_disconnect(conn);
return 0;
}
@@ -1129,24 +1134,25 @@ _handle_legacy(xmpp_conn_t *conn, xmpp_stanza_t *stanza, void *userdata)
type = xmpp_stanza_get_type(stanza);
name = xmpp_stanza_get_name(stanza);
if (!type || strcmp(name, "iq") != 0) {
xmpp_error(conn->ctx, "xmpp",
"Server sent us an unexpected response "
"to legacy authentication request.");
strophe_error(conn->ctx, "xmpp",
"Server sent us an unexpected response "
"to legacy authentication request.");
xmpp_disconnect(conn);
} else if (strcmp(type, "error") == 0) {
/* legacy client auth failed, no more fallbacks */
xmpp_error(conn->ctx, "xmpp", "Legacy client authentication failed.");
strophe_error(conn->ctx, "xmpp",
"Legacy client authentication failed.");
xmpp_disconnect(conn);
} else if (strcmp(type, "result") == 0) {
/* auth succeeded */
xmpp_debug(conn->ctx, "xmpp", "Legacy auth succeeded.");
strophe_debug(conn->ctx, "xmpp", "Legacy auth succeeded.");
conn->authenticated = 1;
conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
} else {
xmpp_error(conn->ctx, "xmpp",
"Server sent us a legacy authentication "
"response with a bad type.");
strophe_error(conn->ctx, "xmpp",
"Server sent us a legacy authentication "
"response with a bad type.");
xmpp_disconnect(conn);
}
@@ -1161,7 +1167,7 @@ static void _auth_legacy(xmpp_conn_t *conn)
xmpp_stanza_t *child;
char *str;
xmpp_debug(conn->ctx, "auth", "Legacy authentication request");
strophe_debug(conn->ctx, "auth", "Legacy authentication request");
iq = xmpp_iq_new(conn->ctx, "set", "_xmpp_auth1");
if (!iq)
@@ -1226,7 +1232,8 @@ static void _auth_legacy(xmpp_conn_t *conn)
} else {
xmpp_stanza_release(authdata);
xmpp_stanza_release(iq);
xmpp_error(conn->ctx, "auth", "Cannot authenticate without resource");
strophe_error(conn->ctx, "auth",
"Cannot authenticate without resource");
xmpp_disconnect(conn);
return;
}
@@ -1260,7 +1267,7 @@ void auth_handle_component_open(xmpp_conn_t *conn)
rc = _handle_component_auth(conn);
if (rc != 0) {
xmpp_error(conn->ctx, "auth", "Component authentication failed.");
strophe_error(conn->ctx, "auth", "Component authentication failed.");
xmpp_disconnect(conn);
}
}
@@ -1274,7 +1281,8 @@ int _handle_component_auth(xmpp_conn_t *conn)
size_t i;
if (conn->stream_id == NULL) {
xmpp_error(conn->ctx, "auth", "Received no stream id from the server.");
strophe_error(conn->ctx, "auth",
"Received no stream id from the server.");
return XMPP_EINT;
}
@@ -1294,19 +1302,19 @@ int _handle_component_auth(xmpp_conn_t *conn)
xmpp_snprintf(digest + i * 2, 3, "%02x", md_value[i]);
digest[2 * sizeof(md_value)] = '\0';
xmpp_debug(conn->ctx, "auth", "Digest: %s, len: %d", digest,
strlen(digest));
strophe_debug(conn->ctx, "auth", "Digest: %s, len: %d", digest,
strlen(digest));
/* Send the digest to the server */
xmpp_send_raw_string(conn, "<handshake xmlns='%s'>%s</handshake>",
XMPP_NS_COMPONENT, digest);
xmpp_debug(conn->ctx, "auth",
"Sent component handshake to the server.");
strophe_debug(conn->ctx, "auth",
"Sent component handshake to the server.");
strophe_free(conn->ctx, digest);
} else {
xmpp_debug(conn->ctx, "auth",
"Couldn't allocate memory for component "
"handshake digest.");
strophe_debug(conn->ctx, "auth",
"Couldn't allocate memory for component "
"handshake digest.");
return XMPP_EMEM;
}
@@ -1332,7 +1340,7 @@ int _handle_component_hs_response(xmpp_conn_t *conn,
size_t msg_size;
xmpp_stanza_to_text(stanza, &msg, &msg_size);
if (msg) {
xmpp_debug(conn->ctx, "auth", "Handshake failed: %s", msg);
strophe_debug(conn->ctx, "auth", "Handshake failed: %s", msg);
strophe_free(conn->ctx, msg);
}
xmpp_disconnect(conn);
@@ -1352,7 +1360,8 @@ int _handle_missing_handshake(xmpp_conn_t *conn, void *userdata)
{
UNUSED(userdata);
xmpp_error(conn->ctx, "xmpp", "Server did not reply to handshake request.");
strophe_error(conn->ctx, "xmpp",
"Server did not reply to handshake request.");
xmpp_disconnect(conn);
return 0;
}
@@ -1367,5 +1376,5 @@ void auth_handle_open_raw(xmpp_conn_t *conn)
void auth_handle_open_stub(xmpp_conn_t *conn)
{
xmpp_warn(conn->ctx, "auth", "Stub callback is called.");
strophe_warn(conn->ctx, "auth", "Stub callback is called.");
}

28
src/common.h
View File

@@ -93,18 +93,24 @@ char *strophe_strdup(const xmpp_ctx_t *ctx, const char *s);
char *strophe_strndup(const xmpp_ctx_t *ctx, const char *s, size_t len);
void strophe_free(const xmpp_ctx_t *ctx, void *p);
void xmpp_log(const xmpp_ctx_t *ctx,
const xmpp_log_level_t level,
const char *area,
const char *fmt,
va_list ap);
/* wrappers for xmpp_log at specific levels */
void xmpp_error(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
void xmpp_warn(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
void xmpp_info(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
void xmpp_debug(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
void xmpp_debug_verbose(
void strophe_error(const xmpp_ctx_t *ctx,
const char *area,
const char *fmt,
...);
void strophe_warn(const xmpp_ctx_t *ctx,
const char *area,
const char *fmt,
...);
void strophe_info(const xmpp_ctx_t *ctx,
const char *area,
const char *fmt,
...);
void strophe_debug(const xmpp_ctx_t *ctx,
const char *area,
const char *fmt,
...);
void strophe_debug_verbose(
int level, const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...);
/** connection **/

110
src/conn.c
View File

@@ -182,7 +182,7 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t *ctx)
item = strophe_alloc(conn->ctx, sizeof(xmpp_connlist_t));
if (!item) {
xmpp_error(conn->ctx, "xmpp", "failed to allocate memory");
strophe_error(conn->ctx, "xmpp", "failed to allocate memory");
strophe_free(conn->ctx, conn->lang);
parser_free(conn->parser);
strophe_free(conn->ctx, conn);
@@ -239,8 +239,9 @@ void xmpp_conn_set_keepalive(xmpp_conn_t *conn, int timeout, int interval)
ret = sock_set_keepalive(conn->sock, timeout, interval);
if (ret < 0) {
xmpp_error(conn->ctx, "xmpp", "Setting TCP keepalive (%d,%d) error: %d",
timeout, interval, sock_error());
strophe_error(conn->ctx, "xmpp",
"Setting TCP keepalive (%d,%d) error: %d", timeout,
interval, sock_error());
}
}
@@ -287,7 +288,8 @@ int xmpp_conn_release(xmpp_conn_t *conn)
}
if (!item) {
xmpp_error(ctx, "xmpp", "Connection not in context's list\n");
strophe_error(ctx, "xmpp",
"Connection not in context's list\n");
} else {
prev->next = item->next;
strophe_free(ctx, item);
@@ -481,7 +483,7 @@ void xmpp_conn_set_client_cert(xmpp_conn_t *const conn,
const char *const cert,
const char *const key)
{
xmpp_debug(conn->ctx, "conn", "set client cert %s %s", cert, key);
strophe_debug(conn->ctx, "conn", "set client cert %s %s", cert, key);
if (conn->tls_client_cert)
strophe_free(conn->ctx, conn->tls_client_cert);
conn->tls_client_cert = strophe_strdup(conn->ctx, cert);
@@ -595,20 +597,20 @@ int xmpp_connect_client(xmpp_conn_t *conn,
if (!conn->jid && conn->tls_client_cert) {
if (tls_id_on_xmppaddr_num(conn) != 1) {
xmpp_debug(conn->ctx, "xmpp",
"Client certificate contains multiple or no xmppAddr "
"and no JID was given to be used.");
strophe_debug(conn->ctx, "xmpp",
"Client certificate contains multiple or no xmppAddr "
"and no JID was given to be used.");
return XMPP_EINVOP;
}
conn->jid = tls_id_on_xmppaddr(conn, 0);
if (!conn->jid)
return XMPP_EMEM;
xmpp_debug(conn->ctx, "xmpp", "Use jid %s from id-on-xmppAddr.",
conn->jid);
strophe_debug(conn->ctx, "xmpp", "Use jid %s from id-on-xmppAddr.",
conn->jid);
}
if (!conn->jid) {
xmpp_error(conn->ctx, "xmpp", "JID is not set.");
strophe_error(conn->ctx, "xmpp", "JID is not set.");
return XMPP_EINVOP;
}
@@ -617,7 +619,7 @@ int xmpp_connect_client(xmpp_conn_t *conn,
return XMPP_EMEM;
if (altdomain != NULL) {
xmpp_debug(conn->ctx, "xmpp", "Connecting via altdomain.");
strophe_debug(conn->ctx, "xmpp", "Connecting via altdomain.");
host = altdomain;
port = altport ? altport : _conn_default_port(conn, XMPP_CLIENT);
found = XMPP_DOMAIN_ALTDOMAIN;
@@ -630,9 +632,9 @@ int xmpp_connect_client(xmpp_conn_t *conn,
}
if (XMPP_DOMAIN_NOT_FOUND == found) {
xmpp_debug(conn->ctx, "xmpp",
"SRV lookup failed, "
"connecting via domain.");
strophe_debug(conn->ctx, "xmpp",
"SRV lookup failed, "
"connecting via domain.");
host = domain;
port = altport ? altport : _conn_default_port(conn, XMPP_CLIENT);
found = XMPP_DOMAIN_ALTDOMAIN;
@@ -691,9 +693,9 @@ int xmpp_connect_component(xmpp_conn_t *conn,
/* XEP-0114 does not support TLS */
xmpp_conn_disable_tls(conn);
if (!conn->tls_disabled) {
xmpp_error(conn->ctx, "conn",
"Failed to disable TLS. "
"XEP-0114 does not support TLS");
strophe_error(conn->ctx, "conn",
"Failed to disable TLS. "
"XEP-0114 does not support TLS");
return XMPP_EINT;
}
@@ -739,7 +741,7 @@ int xmpp_connect_raw(xmpp_conn_t *conn,
void conn_established(xmpp_conn_t *conn)
{
if (conn->tls_legacy_ssl && !conn->is_raw) {
xmpp_debug(conn->ctx, "xmpp", "using legacy SSL connection");
strophe_debug(conn->ctx, "xmpp", "using legacy SSL connection");
if (conn_tls_start(conn) != 0) {
conn_disconnect(conn);
return;
@@ -842,7 +844,7 @@ void conn_disconnect_clean(xmpp_conn_t *conn)
*/
void conn_disconnect(xmpp_conn_t *conn)
{
xmpp_debug(conn->ctx, "xmpp", "Closing socket.");
strophe_debug(conn->ctx, "xmpp", "Closing socket.");
conn->state = XMPP_STATE_DISCONNECTED;
if (conn->tls) {
tls_stop(conn->tls);
@@ -926,8 +928,8 @@ void xmpp_send_raw_string(xmpp_conn_t *conn, const char *fmt, ...)
len++; /* account for trailing \0 */
bigbuf = strophe_alloc(conn->ctx, len);
if (!bigbuf) {
xmpp_debug(conn->ctx, "xmpp",
"Could not allocate memory for send_raw_string");
strophe_debug(conn->ctx, "xmpp",
"Could not allocate memory for send_raw_string");
return;
}
va_start(ap, fmt);
@@ -963,7 +965,7 @@ void xmpp_send_raw(xmpp_conn_t *conn, const char *data, size_t len)
d = strophe_strndup(conn->ctx, data, len);
if (!d) {
xmpp_error(conn->ctx, "conn", "Failed to strndup");
strophe_error(conn->ctx, "conn", "Failed to strndup");
return;
}
@@ -988,7 +990,7 @@ void xmpp_send(xmpp_conn_t *conn, xmpp_stanza_t *stanza)
return;
if (xmpp_stanza_to_text(stanza, &buf, &len) != 0) {
xmpp_error(conn->ctx, "conn", "Failed to stanza_to_text");
strophe_error(conn->ctx, "conn", "Failed to stanza_to_text");
return;
}
@@ -1023,7 +1025,8 @@ void conn_open_stream(xmpp_conn_t *conn)
rc = _conn_open_stream_with_attributes(conn, attributes, attributes_len);
if (rc != XMPP_EOK) {
xmpp_error(conn->ctx, "conn", "Cannot build stream tag: memory error");
strophe_error(conn->ctx, "conn",
"Cannot build stream tag: memory error");
conn_disconnect(conn);
}
if (from)
@@ -1054,10 +1057,10 @@ int conn_tls_start(xmpp_conn_t *conn)
}
}
if (rc != 0) {
xmpp_debug(conn->ctx, "conn",
"Couldn't start TLS! "
"error %d tls_error %d",
rc, conn->error);
strophe_debug(conn->ctx, "conn",
"Couldn't start TLS! "
"error %d tls_error %d",
rc, conn->error);
}
return rc;
}
@@ -1108,15 +1111,15 @@ long xmpp_conn_get_flags(const xmpp_conn_t *conn)
int xmpp_conn_set_flags(xmpp_conn_t *conn, long flags)
{
if (conn->state != XMPP_STATE_DISCONNECTED) {
xmpp_error(conn->ctx, "conn",
"Flags can be set only "
"for disconnected connection");
strophe_error(conn->ctx, "conn",
"Flags can be set only "
"for disconnected connection");
return XMPP_EINVOP;
}
if (flags & XMPP_CONN_FLAG_DISABLE_TLS &&
flags & (XMPP_CONN_FLAG_MANDATORY_TLS | XMPP_CONN_FLAG_LEGACY_SSL |
XMPP_CONN_FLAG_TRUST_TLS)) {
xmpp_error(conn->ctx, "conn", "Flags 0x%04lx conflict", flags);
strophe_error(conn->ctx, "conn", "Flags 0x%04lx conflict", flags);
return XMPP_EINVOP;
}
@@ -1194,7 +1197,7 @@ static int _disconnect_cleanup(xmpp_conn_t *conn, void *userdata)
{
UNUSED(userdata);
xmpp_debug(conn->ctx, "xmpp", "disconnection forced by cleanup timeout");
strophe_debug(conn->ctx, "xmpp", "disconnection forced by cleanup timeout");
conn_disconnect(conn);
@@ -1236,9 +1239,9 @@ static char *_conn_build_stream_tag(xmpp_conn_t *conn,
strcat(tag, tag_tail);
if (strlen(tag) != len) {
xmpp_error(conn->ctx, "xmpp",
"Internal error in "
"_conn_build_stream_tag().");
strophe_error(conn->ctx, "xmpp",
"Internal error in "
"_conn_build_stream_tag().");
strophe_free(conn->ctx, tag);
tag = NULL;
}
@@ -1282,7 +1285,7 @@ static void _conn_attributes_new(xmpp_conn_t *conn,
break;
}
if (!array || i < nr) {
xmpp_error(conn->ctx, "xmpp", "Memory allocation error.");
strophe_error(conn->ctx, "xmpp", "Memory allocation error.");
_conn_attributes_destroy(conn, array, i);
array = NULL;
nr = 0;
@@ -1314,7 +1317,7 @@ static void _log_open_tag(xmpp_conn_t *conn, char **attrs)
_conn_attributes_new(conn, attrs, &attributes, &nr);
tag = _conn_build_stream_tag(conn, attributes, nr);
if (tag) {
xmpp_debug(conn->ctx, "xmpp", "RECV: %s", tag);
strophe_debug(conn->ctx, "xmpp", "RECV: %s", tag);
strophe_free(conn->ctx, tag);
}
_conn_attributes_destroy(conn, attributes, nr);
@@ -1351,14 +1354,14 @@ static void _handle_stream_start(char *name, char **attrs, void *userdata)
conn->stream_id = strophe_strdup(conn->ctx, id);
if (id && !conn->stream_id) {
xmpp_error(conn->ctx, "conn", "Memory allocation failed.");
strophe_error(conn->ctx, "conn", "Memory allocation failed.");
failed = 1;
}
} else {
xmpp_error(conn->ctx, "conn",
"Server did not open valid stream."
" name = %s.",
name);
strophe_error(conn->ctx, "conn",
"Server did not open valid stream."
" name = %s.",
name);
failed = 1;
}
@@ -1377,7 +1380,7 @@ static void _handle_stream_end(char *name, void *userdata)
UNUSED(name);
/* stream is over */
xmpp_debug(conn->ctx, "xmpp", "RECV: </stream:stream>");
strophe_debug(conn->ctx, "xmpp", "RECV: </stream:stream>");
conn_disconnect_clean(conn);
}
@@ -1388,7 +1391,7 @@ static void _handle_stream_stanza(xmpp_stanza_t *stanza, void *userdata)
size_t len;
if (xmpp_stanza_to_text(stanza, &buf, &len) == 0) {
xmpp_debug(conn->ctx, "xmpp", "RECV: %s", buf);
strophe_debug(conn->ctx, "xmpp", "RECV: %s", buf);
strophe_free(conn->ctx, buf);
}
@@ -1415,7 +1418,7 @@ static void _conn_reset(xmpp_conn_t *conn)
xmpp_send_queue_t *sq, *tsq;
if (conn->state != XMPP_STATE_DISCONNECTED) {
xmpp_debug(ctx, "conn", "Can't reset connected object.");
strophe_debug(ctx, "conn", "Can't reset connected object.");
return;
}
@@ -1485,8 +1488,8 @@ static int _conn_connect(xmpp_conn_t *conn,
return XMPP_EMEM;
conn->sock = sock_connect(host, port);
xmpp_debug(conn->ctx, "xmpp", "sock_connect() to %s:%u returned %d", host,
port, conn->sock);
strophe_debug(conn->ctx, "xmpp", "sock_connect() to %s:%u returned %d",
host, port, conn->sock);
if (conn->sock == -1)
return XMPP_EINT;
if (conn->ka_timeout || conn->ka_interval)
@@ -1508,7 +1511,7 @@ static int _conn_connect(xmpp_conn_t *conn,
conn->state = XMPP_STATE_CONNECTING;
conn->timeout_stamp = time_stamp();
xmpp_debug(conn->ctx, "xmpp", "Attempting to connect to %s", host);
strophe_debug(conn->ctx, "xmpp", "Attempting to connect to %s", host);
return 0;
}
@@ -1520,7 +1523,7 @@ static int _send_raw(xmpp_conn_t *conn, char *data, size_t len)
/* create send queue item for queue */
item = strophe_alloc(conn->ctx, sizeof(xmpp_send_queue_t));
if (!item) {
xmpp_error(conn->ctx, "conn", "DROPPED: %s", data);
strophe_error(conn->ctx, "conn", "DROPPED: %s", data);
strophe_free(conn->ctx, data);
return XMPP_EMEM;
}
@@ -1541,7 +1544,8 @@ static int _send_raw(xmpp_conn_t *conn, char *data, size_t len)
conn->send_queue_tail = item;
}
conn->send_queue_len++;
xmpp_debug_verbose(2, conn->ctx, "conn", "QUEUED: %s", data);
xmpp_debug_verbose(1, conn->ctx, "conn", "Added queue element: %p", item);
strophe_debug_verbose(2, conn->ctx, "conn", "QUEUED: %s", data);
strophe_debug_verbose(1, conn->ctx, "conn", "Added queue element: %p",
item);
return XMPP_EOK;
}

41
src/ctx.c
View File

@@ -264,11 +264,11 @@ void *strophe_realloc(const xmpp_ctx_t *ctx, void *p, size_t size)
* @param fmt a printf-style format string for the message
* @param ap variable argument list supplied for the format string
*/
void xmpp_log(const xmpp_ctx_t *ctx,
xmpp_log_level_t level,
const char *area,
const char *fmt,
va_list ap)
static void _strophe_log(const xmpp_ctx_t *ctx,
xmpp_log_level_t level,
const char *area,
const char *fmt,
va_list ap)
{
int oldret, ret;
char smbuf[1024];
@@ -288,14 +288,15 @@ void xmpp_log(const xmpp_ctx_t *ctx,
buf = (char *)strophe_alloc(ctx, ret + 1);
if (!buf) {
buf = NULL;
xmpp_error(ctx, "log", "Failed allocating memory for log message.");
strophe_error(ctx, "log",
"Failed allocating memory for log message.");
va_end(copy);
return;
}
oldret = ret;
ret = xmpp_vsnprintf(buf, ret + 1, fmt, copy);
if (ret > oldret) {
xmpp_error(ctx, "log", "Unexpected error");
strophe_error(ctx, "log", "Unexpected error");
strophe_free(ctx, buf);
va_end(copy);
return;
@@ -321,12 +322,15 @@ void xmpp_log(const xmpp_ctx_t *ctx,
* @param fmt a printf-style format string followed by a variable list of
* arguments to format
*/
void xmpp_error(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
void strophe_error(const xmpp_ctx_t *ctx,
const char *area,
const char *fmt,
...)
{
va_list ap;
va_start(ap, fmt);
xmpp_log(ctx, XMPP_LEVEL_ERROR, area, fmt, ap);
_strophe_log(ctx, XMPP_LEVEL_ERROR, area, fmt, ap);
va_end(ap);
}
@@ -340,12 +344,12 @@ void xmpp_error(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
* @param fmt a printf-style format string followed by a variable list of
* arguments to format
*/
void xmpp_warn(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
void strophe_warn(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
xmpp_log(ctx, XMPP_LEVEL_WARN, area, fmt, ap);
_strophe_log(ctx, XMPP_LEVEL_WARN, area, fmt, ap);
va_end(ap);
}
@@ -359,12 +363,12 @@ void xmpp_warn(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
* @param fmt a printf-style format string followed by a variable list of
* arguments to format
*/
void xmpp_info(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
void strophe_info(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
xmpp_log(ctx, XMPP_LEVEL_INFO, area, fmt, ap);
_strophe_log(ctx, XMPP_LEVEL_INFO, area, fmt, ap);
va_end(ap);
}
@@ -378,12 +382,15 @@ void xmpp_info(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
* @param fmt a printf-style format string followed by a variable list of
* arguments to format
*/
void xmpp_debug(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
void strophe_debug(const xmpp_ctx_t *ctx,
const char *area,
const char *fmt,
...)
{
va_list ap;
va_start(ap, fmt);
xmpp_log(ctx, XMPP_LEVEL_DEBUG, area, fmt, ap);
_strophe_log(ctx, XMPP_LEVEL_DEBUG, area, fmt, ap);
va_end(ap);
}
@@ -398,7 +405,7 @@ void xmpp_debug(const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
* @param fmt a printf-style format string followed by a variable list of
* arguments to format
*/
void xmpp_debug_verbose(
void strophe_debug_verbose(
int level, const xmpp_ctx_t *ctx, const char *area, const char *fmt, ...)
{
va_list ap;
@@ -407,7 +414,7 @@ void xmpp_debug_verbose(
return;
va_start(ap, fmt);
xmpp_log(ctx, XMPP_LEVEL_DEBUG, area, fmt, ap);
_strophe_log(ctx, XMPP_LEVEL_DEBUG, area, fmt, ap);
va_end(ap);
}

38
src/event.c
View File

@@ -107,7 +107,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout)
if (ret < 0 && !tls_is_recoverable(tls_error(conn->tls))) {
/* an error occurred */
xmpp_debug(ctx, "xmpp", "Send error occurred, disconnecting.");
strophe_debug(ctx, "xmpp",
"Send error occurred, disconnecting.");
conn->error = ECONNABORTED;
conn_disconnect(conn);
goto next_item;
@@ -134,9 +135,9 @@ void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout)
break; /* partial write or an error */
/* all data for this queue item written, delete and move on */
xmpp_debug(conn->ctx, "conn", "SENT: %s", sq->data);
xmpp_debug_verbose(1, ctx, "xmpp",
"Finished writing queue element: %p.", sq);
strophe_debug(conn->ctx, "conn", "SENT: %s", sq->data);
strophe_debug_verbose(1, ctx, "xmpp",
"Finished writing queue element: %p.", sq);
strophe_free(ctx, sq->data);
tsq = sq;
sq = sq->next;
@@ -154,7 +155,7 @@ void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout)
if (conn->error) {
/* FIXME: need to tear down send queues and random other things
* maybe this should be abstracted */
xmpp_debug(ctx, "xmpp", "Send error occurred, disconnecting.");
strophe_debug(ctx, "xmpp", "Send error occurred, disconnecting.");
conn->error = ECONNABORTED;
conn_disconnect(conn);
}
@@ -195,7 +196,7 @@ next_item:
FD_SET(conn->sock, &wfds);
else {
conn->error = ETIMEDOUT;
xmpp_info(ctx, "xmpp", "Connection attempt timed out.");
strophe_info(ctx, "xmpp", "Connection attempt timed out.");
conn_disconnect(conn);
}
break;
@@ -232,8 +233,8 @@ next_item:
/* select errored */
if (ret < 0) {
if (!sock_is_recoverable(sock_error()))
xmpp_error(ctx, "xmpp", "event watcher internal error %d",
sock_error());
strophe_error(ctx, "xmpp", "event watcher internal error %d",
sock_error());
return;
}
@@ -255,13 +256,14 @@ next_item:
ret = sock_connect_error(conn->sock);
if (ret != 0) {
/* connection failed */
xmpp_debug(ctx, "xmpp", "connection failed, error %d", ret);
strophe_debug(ctx, "xmpp", "connection failed, error %d",
ret);
conn_disconnect(conn);
break;
}
conn->state = XMPP_STATE_CONNECTED;
xmpp_debug(ctx, "xmpp", "connection successful");
strophe_debug(ctx, "xmpp", "connection successful");
conn_established(conn);
}
@@ -279,23 +281,23 @@ next_item:
if (ret > 0) {
ret = parser_feed(conn->parser, buf, ret);
if (!ret) {
xmpp_debug(ctx, "xmpp", "parse error [%s]", buf);
strophe_debug(ctx, "xmpp", "parse error [%s]", buf);
xmpp_send_error(conn, XMPP_SE_INVALID_XML,
"parse error");
}
} else {
if (conn->tls) {
if (!tls_is_recoverable(tls_error(conn->tls))) {
xmpp_debug(ctx, "xmpp",
"Unrecoverable TLS error, %d.",
tls_error(conn->tls));
strophe_debug(ctx, "xmpp",
"Unrecoverable TLS error, %d.",
tls_error(conn->tls));
conn->error = tls_error(conn->tls);
conn_disconnect(conn);
}
} else {
/* return of 0 means socket closed by server */
xmpp_debug(ctx, "xmpp",
"Socket closed by remote host.");
strophe_debug(ctx, "xmpp",
"Socket closed by remote host.");
conn->error = ECONNRESET;
conn_disconnect(conn);
}
@@ -337,7 +339,7 @@ void xmpp_run(xmpp_ctx_t *ctx)
/* make it possible to start event loop again */
ctx->loop_status = XMPP_LOOP_NOTSTARTED;
xmpp_debug(ctx, "event", "Event loop completed.");
strophe_debug(ctx, "event", "Event loop completed.");
}
/** Stop the event loop.
@@ -350,7 +352,7 @@ void xmpp_run(xmpp_ctx_t *ctx)
*/
void xmpp_stop(xmpp_ctx_t *ctx)
{
xmpp_debug(ctx, "event", "Stopping event loop.");
strophe_debug(ctx, "event", "Stopping event loop.");
if (ctx->loop_status == XMPP_LOOP_RUNNING)
ctx->loop_status = XMPP_LOOP_QUIT;

6
src/handler.c
View File

@@ -267,7 +267,7 @@ static void _timed_handler_add(xmpp_ctx_t *ctx,
/* check if handler is already in the list */
for (item = *handlers_list; item; item = item->next) {
if (item->handler == handler && item->userdata == userdata) {
xmpp_warn(ctx, "xmpp", "Timed handler already exists.");
strophe_warn(ctx, "xmpp", "Timed handler already exists.");
break;
}
}
@@ -333,7 +333,7 @@ static void _id_handler_add(xmpp_conn_t *conn,
item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
while (item) {
if (item->handler == handler && item->userdata == userdata) {
xmpp_warn(conn->ctx, "xmpp", "Id handler already exists.");
strophe_warn(conn->ctx, "xmpp", "Id handler already exists.");
break;
}
item = item->next;
@@ -435,7 +435,7 @@ static void _handler_add(xmpp_conn_t *conn,
/* same handler function can process different stanzas and
distinguish them according to userdata. */
if (item->handler == handler && item->userdata == userdata) {
xmpp_warn(conn->ctx, "xmpp", "Stanza handler already exists.");
strophe_warn(conn->ctx, "xmpp", "Stanza handler already exists.");
break;
}
}

3
src/parser_expat.c
View File

@@ -181,7 +181,8 @@ _start_element(void *userdata, const XML_Char *nsname, const XML_Char **attrs)
if (!parser->stanza && parser->depth != 1) {
/* something terrible happened */
/* FIXME: shutdown disconnect */
xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");
strophe_error(parser->ctx, "parser",
"oops, where did our stanza go?");
} else {
child = xmpp_stanza_new(parser->ctx);
if (!child) {

3
src/parser_libxml2.c
View File

@@ -140,7 +140,8 @@ static void _start_element(void *userdata,
if (!parser->stanza && parser->depth != 1) {
/* something terrible happened */
/* FIXME: we should probably trigger a disconnect */
xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");
strophe_error(parser->ctx, "parser",
"oops, where did our stanza go?");
} else if (!parser->stanza) {
/* starting a new toplevel stanza */
parser->stanza = xmpp_stanza_new(parser->ctx);

6
src/sasl.c
View File

@@ -102,7 +102,7 @@ static hash_t *_parse_digest_challenge(xmpp_ctx_t *ctx, const char *msg)
text = (unsigned char *)xmpp_base64_decode_str(ctx, msg, strlen(msg));
if (text == NULL) {
xmpp_error(ctx, "SASL", "couldn't Base64 decode challenge!");
strophe_error(ctx, "SASL", "couldn't Base64 decode challenge!");
return NULL;
}
@@ -191,7 +191,7 @@ _add_key(xmpp_ctx_t *ctx, hash_t *table, const char *key, char *buf, int quote)
olen = strlen(buf);
value = hash_get(table, key);
if (value == NULL) {
xmpp_error(ctx, "SASL", "couldn't retrieve value for '%s'", key);
strophe_error(ctx, "SASL", "couldn't retrieve value for '%s'", key);
value = "";
}
if (quote) {
@@ -254,7 +254,7 @@ char *sasl_digest_md5(xmpp_ctx_t *ctx,
/* parse the challenge */
table = _parse_digest_challenge(ctx, challenge);
if (table == NULL) {
xmpp_error(ctx, "SASL", "couldn't parse digest challenge");
strophe_error(ctx, "SASL", "couldn't parse digest challenge");
return NULL;
}

15
src/tls_gnutls.c
View File

@@ -235,7 +235,8 @@ static xmpp_tlscert_t *_x509_to_tlscert(xmpp_ctx_t *ctx, gnutls_x509_crt_t cert)
res = gnutls_x509_crt_get_subject_alt_name(cert, n, buf, &size, NULL);
if (res == GNUTLS_SAN_DNSNAME) {
if (tlscert_add_dnsname(tlscert, buf))
xmpp_debug(ctx, "tls", "Can't store dnsName(%zu): %s", m, buf);
strophe_debug(ctx, "tls", "Can't store dnsName(%zu): %s", m,
buf);
m++;
}
}
@@ -256,13 +257,13 @@ static int _tls_verify(gnutls_session_t session)
return -1;
if (gnutls_certificate_verify_peers2(session, &status) < 0) {
xmpp_error(tls->ctx, "tls", "Verify peers failed");
strophe_error(tls->ctx, "tls", "Verify peers failed");
return -1;
}
type = gnutls_certificate_type_get(session);
if (gnutls_certificate_verification_status_print(status, type, &out, 0) <
0) {
xmpp_error(tls->ctx, "tls", "Status print failed");
strophe_error(tls->ctx, "tls", "Status print failed");
return -1;
}
@@ -272,8 +273,8 @@ static int _tls_verify(gnutls_session_t session)
return 0;
if (!tls->conn->certfail_handler) {
xmpp_error(tls->ctx, "tls",
"No certfail handler set, canceling connection attempt");
strophe_error(tls->ctx, "tls",
"No certfail handler set, canceling connection attempt");
return -1;
}
@@ -326,8 +327,8 @@ tls_t *tls_new(xmpp_conn_t *conn)
if (conn->tls_client_cert && conn->tls_client_key) {
tls->client_cert = _tls_load_cert(conn);
if (!tls->client_cert) {
xmpp_error(tls->ctx, "tls",
"could not read client certificate");
strophe_error(tls->ctx, "tls",
"could not read client certificate");
gnutls_certificate_free_credentials(tls->cred);
gnutls_deinit(tls->session);
strophe_free(tls->ctx, tls);

57
src/tls_openssl.c
View File

@@ -269,8 +269,8 @@ char *tls_id_on_xmppaddr(xmpp_conn_t *conn, unsigned int n)
if (_tls_xmppaddr_to_string(name, &res))
continue;
if (j == (int)n) {
xmpp_debug(conn->ctx, "tls", "extracted jid %s from id-on-xmppAddr",
res);
strophe_debug(conn->ctx, "tls",
"extracted jid %s from id-on-xmppAddr", res);
ret = strophe_strdup(conn->ctx, res);
OPENSSL_free(res);
break;
@@ -459,7 +459,8 @@ static xmpp_tlscert_t *_x509_to_tlscert(xmpp_ctx_t *ctx, X509 *cert)
if (_tls_dnsname_to_string(name, &res))
continue;
if (tlscert_add_dnsname(tlscert, res))
xmpp_debug(ctx, "tls", "Can't store dnsName(%zu): %s", n, res);
strophe_debug(ctx, "tls", "Can't store dnsName(%zu): %s", n,
res);
n++;
OPENSSL_free(res);
}
@@ -482,8 +483,8 @@ static int _tls_verify(int preverify_ok, X509_STORE_CTX *x509_ctx)
xmpp_conn_t *conn = SSL_get_app_data(ssl);
if (!conn->certfail_handler) {
xmpp_error(conn->ctx, "tls",
"No certfail handler set, canceling connection attempt");
strophe_error(conn->ctx, "tls",
"No certfail handler set, canceling connection attempt");
return 0;
}
@@ -494,9 +495,9 @@ static int _tls_verify(int preverify_ok, X509_STORE_CTX *x509_ctx)
if (!tlscert)
return 0;
xmpp_debug(conn->ctx, "tls", "preverify_ok:%d\nSubject: %s\nIssuer: %s",
preverify_ok, tlscert->elements[XMPP_CERT_SUBJECT],
tlscert->elements[XMPP_CERT_ISSUER]);
strophe_debug(conn->ctx, "tls", "preverify_ok:%d\nSubject: %s\nIssuer: %s",
preverify_ok, tlscert->elements[XMPP_CERT_SUBJECT],
tlscert->elements[XMPP_CERT_ISSUER]);
int ret = conn->certfail_handler(
tlscert,
@@ -540,8 +541,8 @@ tls_t *tls_new(xmpp_conn_t *conn)
if (conn->tls_client_cert && conn->tls_client_key) {
tls->client_cert = _tls_cert_read(conn);
if (!tls->client_cert) {
xmpp_error(tls->ctx, "tls",
"could not read client certificate");
strophe_error(tls->ctx, "tls",
"could not read client certificate");
goto err_free_ctx;
}
@@ -563,16 +564,16 @@ tls_t *tls_new(xmpp_conn_t *conn)
* location is still treated as a success.
* Ignore errors when XMPP_CONN_FLAG_TRUST_TLS is set.
*/
xmpp_error(tls->ctx, "tls",
"SSL_CTX_set_default_verify_paths() failed");
strophe_error(tls->ctx, "tls",
"SSL_CTX_set_default_verify_paths() failed");
goto err_free_cert;
}
if (conn->tls_cafile || conn->tls_capath) {
if (SSL_CTX_load_verify_locations(tls->ssl_ctx, conn->tls_cafile,
conn->tls_capath) == 0) {
xmpp_error(tls->ctx, "tls",
"SSL_CTX_load_verify_locations() failed");
strophe_error(tls->ctx, "tls",
"SSL_CTX_load_verify_locations() failed");
goto err_free_cert;
}
}
@@ -680,13 +681,13 @@ int tls_start(tls_t *tls)
x509_res = SSL_get_verify_result(tls->ssl);
if (x509_res == X509_V_OK) {
xmpp_debug(tls->ctx, "tls", "Certificate verification passed");
strophe_debug(tls->ctx, "tls", "Certificate verification passed");
} else {
xmpp_debug(tls->ctx, "tls",
"Certificate verification FAILED, result=%s(%ld)",
TLS_ERROR_STR((int)x509_res, cert_errors), x509_res);
strophe_debug(tls->ctx, "tls",
"Certificate verification FAILED, result=%s(%ld)",
TLS_ERROR_STR((int)x509_res, cert_errors), x509_res);
if (ret > 0)
xmpp_debug(tls->ctx, "tls", "User decided to connect anyways");
strophe_debug(tls->ctx, "tls", "User decided to connect anyways");
}
_tls_dump_cert_info(tls);
@@ -801,8 +802,8 @@ static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size)
static void _tls_set_error(tls_t *tls, int error)
{
if (error != 0 && !tls_is_recoverable(error)) {
xmpp_debug(tls->ctx, "tls", "error=%s(%d) errno=%d",
TLS_ERROR_STR(error, tls_errors), error, errno);
strophe_debug(tls->ctx, "tls", "error=%s(%d) errno=%d",
TLS_ERROR_STR(error, tls_errors), error, errno);
_tls_log_error(tls->ctx);
}
tls->lasterror = error;
@@ -815,9 +816,9 @@ static void _tls_log_error(xmpp_ctx_t *ctx)
do {
e = ERR_get_error();
if (e != 0) {
xmpp_debug(ctx, "tls", "error:%08uX:%s:%s:%s", e,
ERR_lib_error_string(e), ERR_func_error_string(e),
ERR_reason_error_string(e));
strophe_debug(ctx, "tls", "error:%08uX:%s:%s:%s", e,
ERR_lib_error_string(e), ERR_func_error_string(e),
ERR_reason_error_string(e));
}
} while (e != 0);
}
@@ -829,16 +830,16 @@ static void _tls_dump_cert_info(tls_t *tls)
cert = SSL_get_peer_certificate(tls->ssl);
if (cert == NULL)
xmpp_debug(tls->ctx, "tls", "Certificate was not presented by peer");
strophe_debug(tls->ctx, "tls", "Certificate was not presented by peer");
else {
name = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
if (name != NULL) {
xmpp_debug(tls->ctx, "tls", "Subject=%s", name);
strophe_debug(tls->ctx, "tls", "Subject=%s", name);
OPENSSL_free(name);
}
name = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
if (name != NULL) {
xmpp_debug(tls->ctx, "tls", "Issuer=%s", name);
strophe_debug(tls->ctx, "tls", "Issuer=%s", name);
OPENSSL_free(name);
}
X509_free(cert);
@@ -851,7 +852,7 @@ static X509 *_tls_cert_read(xmpp_conn_t *conn)
return conn->tls->client_cert;
BIO *f = BIO_new_file(conn->tls_client_cert, "r");
if (!f) {
xmpp_debug(conn->ctx, "tls", "f == NULL");
strophe_debug(conn->ctx, "tls", "f == NULL");
return NULL;
}
X509 *c = PEM_read_bio_X509(f, NULL, NULL, NULL);

4
src/util.c
View File

@@ -65,7 +65,7 @@ char *strophe_strndup(const xmpp_ctx_t *ctx, const char *s, size_t len)
copy = strophe_alloc(ctx, l + 1);
if (!copy) {
xmpp_error(ctx, "xmpp", "failed to allocate required memory");
strophe_error(ctx, "xmpp", "failed to allocate required memory");
return NULL;
}
@@ -157,7 +157,7 @@ uint64_t time_elapsed(uint64_t t1, uint64_t t2)
*/
void disconnect_mem_error(xmpp_conn_t *conn)
{
xmpp_error(conn->ctx, "xmpp", "Memory allocation error");
strophe_error(conn->ctx, "xmpp", "Memory allocation error");
xmpp_disconnect(conn);
}

2
tests/test_ctx.c
View File

@@ -81,7 +81,7 @@ int main()
mylog.userdata = my_str;
ctx = xmpp_ctx_new(&mymem, &mylog);
xmpp_debug(ctx, "test", "hello");
strophe_debug(ctx, "test", "hello");
testptr1 = strophe_alloc(ctx, 1024);
if (testptr1 == NULL) {