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

Unify coding style

Browse Source 
@sjaeckel integrated clang-format with formal coding style. Run his
script and commit changes.

There are pros and cons of this commit.

Mixed coding style is a "broken window". A good single style simplifies
reading and writing code.

On the other hand, this is a big change which will lead to conflicts.
This commit is contained in:
Dmitry Podgorny
2020-01-03 22:02:22 +02:00
parent eef07cef36
commit 562a06425b
62 changed files with 3972 additions and 3746 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
examples/active.c
View File

@@ -44,8 +44,10 @@ int handle_reply(xmpp_conn_t * const conn,
return 0;
}
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
const int error, xmpp_stream_error_t * const stream_error,
void conn_handler(xmpp_conn_t *const conn,
const xmpp_conn_event_t status,
const int error,
xmpp_stream_error_t *const stream_error,
void *const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;

15
examples/basic.c
View File

@@ -19,8 +19,10 @@
#define KA_INTERVAL 1
/* define a handler for connection events */
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
const int error, xmpp_stream_error_t * const stream_error,
void conn_handler(xmpp_conn_t *const conn,
const xmpp_conn_event_t status,
const int error,
xmpp_stream_error_t *const stream_error,
void *const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
@@ -32,8 +34,7 @@ void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
fprintf(stderr, "DEBUG: connection is %s.\n",
secured ? "secured" : "NOT secured");
xmpp_disconnect(conn);
}
else {
} else {
fprintf(stderr, "DEBUG: disconnected\n");
xmpp_stop(ctx);
}
@@ -87,8 +88,9 @@ int main(int argc, char **argv)
/* init library */
xmpp_initialize();
/* pass NULL instead to silence output */
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
/* create a context */
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
ctx = xmpp_ctx_new(NULL, log);
/* create a connection */
@@ -97,7 +99,8 @@ int main(int argc, char **argv)
/* configure connection properties (optional) */
xmpp_conn_set_flags(conn, flags);
/* configure TCP keepalive (optional) */
if (tcp_keepalive) xmpp_conn_set_keepalive(conn, KA_TIMEOUT, KA_INTERVAL);
if (tcp_keepalive)
xmpp_conn_set_keepalive(conn, KA_TIMEOUT, KA_INTERVAL);
/* setup authentication information */
xmpp_conn_set_jid(conn, jid);

28
examples/bot.c
View File

@@ -22,8 +22,9 @@
#include <strophe.h>
int version_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
int version_handler(xmpp_conn_t *const conn,
xmpp_stanza_t *const stanza,
void *const userdata)
{
xmpp_stanza_t *reply, *query, *name, *version, *text;
const char *ns;
@@ -69,8 +70,9 @@ int version_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void
return 1;
}
int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
int message_handler(xmpp_conn_t *const conn,
xmpp_stanza_t *const stanza,
void *const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
xmpp_stanza_t *body, *reply;
@@ -87,7 +89,8 @@ int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void
intext = xmpp_stanza_get_text(body);
printf("Incoming message from %s: %s\n", xmpp_stanza_get_from(stanza), intext);
printf("Incoming message from %s: %s\n", xmpp_stanza_get_from(stanza),
intext);
reply = xmpp_stanza_reply(stanza);
if (xmpp_stanza_get_type(reply) == NULL)
@@ -115,8 +118,10 @@ int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void
}
/* define a handler for connection events */
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
const int error, xmpp_stream_error_t * const stream_error,
void conn_handler(xmpp_conn_t *const conn,
const xmpp_conn_event_t status,
const int error,
xmpp_stream_error_t *const stream_error,
void *const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
@@ -124,15 +129,15 @@ void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
if (status == XMPP_CONN_CONNECT) {
xmpp_stanza_t *pres;
fprintf(stderr, "DEBUG: connected\n");
xmpp_handler_add(conn, version_handler, "jabber:iq:version", "iq", NULL, ctx);
xmpp_handler_add(conn, version_handler, "jabber:iq:version", "iq", NULL,
ctx);
xmpp_handler_add(conn, message_handler, NULL, "message", NULL, ctx);
/* Send initial <presence/> so that we appear online to contacts */
pres = xmpp_presence_new(ctx);
xmpp_send(conn, pres);
xmpp_stanza_release(pres);
}
else {
} else {
fprintf(stderr, "DEBUG: disconnected\n");
xmpp_stop(ctx);
}
@@ -157,8 +162,9 @@ int main(int argc, char **argv)
/* init library */
xmpp_initialize();
/* pass NULL instead to silence output */
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
/* create a context */
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
ctx = xmpp_ctx_new(NULL, log);
/* create a connection */

14
examples/component.c
View File

@@ -19,10 +19,11 @@
#include <strophe.h>
/* define a handler for connection events */
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
const int error, xmpp_stream_error_t * const stream_error,
void conn_handler(xmpp_conn_t *const conn,
const xmpp_conn_event_t status,
const int error,
xmpp_stream_error_t *const stream_error,
void *const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
@@ -30,8 +31,7 @@ void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
if (status == XMPP_CONN_CONNECT) {
fprintf(stderr, "DEBUG: connected\n");
xmpp_disconnect(conn);
}
else {
} else {
fprintf(stderr, "DEBUG: disconnected\n");
xmpp_stop(ctx);
}
@@ -67,8 +67,9 @@ int main(int argc, char **argv)
/* init library */
xmpp_initialize();
/* pass NULL instead to silence output */
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
/* create a context */
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
ctx = xmpp_ctx_new(NULL, log);
/* create a connection */
@@ -94,4 +95,3 @@ int main(int argc, char **argv)
return 0;
}

21
examples/register.c
View File

@@ -36,9 +36,8 @@ typedef struct {
#define FEATURES_TIMEOUT 5000 /* 5 seconds */
static void iq_reg_send_form(xmpp_reg_t *reg,
xmpp_conn_t *conn,
xmpp_stanza_t *stanza)
static void
iq_reg_send_form(xmpp_reg_t *reg, xmpp_conn_t *conn, xmpp_stanza_t *stanza)
{
xmpp_ctx_t *ctx = reg->ctx;
xmpp_stanza_t *query;
@@ -221,8 +220,8 @@ static int _handle_features(xmpp_conn_t * const conn,
child = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(child, "starttls");
xmpp_stanza_set_ns(child, XMPP_NS_TLS);
xmpp_handler_add(conn, _handle_proceedtls_default,
XMPP_NS_TLS, NULL, NULL, NULL);
xmpp_handler_add(conn, _handle_proceedtls_default, XMPP_NS_TLS, NULL,
NULL, NULL);
xmpp_send(conn, child);
xmpp_stanza_release(child);
return 0;
@@ -274,14 +273,14 @@ static void conn_handler(xmpp_conn_t * const conn,
secured ? "secured" : "NOT secured");
/* setup handler for stream:error */
xmpp_handler_add(conn, _handle_error, XMPP_NS_STREAMS,
"error", NULL, NULL);
xmpp_handler_add(conn, _handle_error, XMPP_NS_STREAMS, "error", NULL,
NULL);
/* setup handlers for incoming <stream:features> */
xmpp_handler_add(conn, _handle_features, XMPP_NS_STREAMS,
"features", NULL, reg);
xmpp_timed_handler_add(conn, _handle_missing_features,
FEATURES_TIMEOUT, NULL);
xmpp_handler_add(conn, _handle_features, XMPP_NS_STREAMS, "features",
NULL, reg);
xmpp_timed_handler_add(conn, _handle_missing_features, FEATURES_TIMEOUT,
NULL);
} else {
fprintf(stderr, "DEBUG: disconnected\n");
xmpp_stop(reg->ctx);

12
examples/roster.c
View File

@@ -34,13 +34,11 @@ int handle_reply(xmpp_conn_t * const conn,
for (item = xmpp_stanza_get_children(query); item;
item = xmpp_stanza_get_next(item))
if ((name = xmpp_stanza_get_attribute(item, "name")))
printf("\t %s (%s) sub=%s\n",
name,
printf("\t %s (%s) sub=%s\n", name,
xmpp_stanza_get_attribute(item, "jid"),
xmpp_stanza_get_attribute(item, "subscription"));
else
printf("\t %s sub=%s\n",
xmpp_stanza_get_attribute(item, "jid"),
printf("\t %s sub=%s\n", xmpp_stanza_get_attribute(item, "jid"),
xmpp_stanza_get_attribute(item, "subscription"));
printf("END OF LIST\n");
}
@@ -51,8 +49,10 @@ int handle_reply(xmpp_conn_t * const conn,
return 0;
}
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
const int error, xmpp_stream_error_t * const stream_error,
void conn_handler(xmpp_conn_t *const conn,
const xmpp_conn_event_t status,
const int error,
xmpp_stream_error_t *const stream_error,
void *const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;

25
examples/vcard.c
View File

@@ -76,8 +76,8 @@ static void vcard_photo(vcard_t *vc, xmpp_stanza_t *stanza)
xmpp_free(vc->ctx, img);
}
static void vcard_print_string(vcard_t *vc, xmpp_stanza_t *stanza,
const char *info)
static void
vcard_print_string(vcard_t *vc, xmpp_stanza_t *stanza, const char *info)
{
char *s = xmpp_stanza_get_text(stanza);
@@ -140,14 +140,9 @@ static vcard_cb_t vcard_cb_get(xmpp_stanza_t *stanza)
const char *tag;
vcard_cb_t cb;
} vcard_tbl[] = {
{ "PHOTO", vcard_photo },
{ "BDAY", vcard_bday },
{ "DESC", vcard_desc },
{ "EMAIL", vcard_email },
{ "FN", vcard_fn },
{ "N", vcard_name },
{ "NICKNAME", vcard_nick },
{ "URL", vcard_url },
{"PHOTO", vcard_photo}, {"BDAY", vcard_bday}, {"DESC", vcard_desc},
{"EMAIL", vcard_email}, {"FN", vcard_fn}, {"N", vcard_name},
{"NICKNAME", vcard_nick}, {"URL", vcard_url},
};
tag = xmpp_stanza_get_name(stanza);
@@ -173,7 +168,8 @@ static int timedout(xmpp_conn_t * const conn, void * const userdata)
return 0;
}
static int recv_vcard(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
static int recv_vcard(xmpp_conn_t *const conn,
xmpp_stanza_t *const stanza,
void *const userdata)
{
vcard_t *vc = userdata;
@@ -213,7 +209,8 @@ exit:
static void send_vcard_req(xmpp_conn_t *conn, const char *to, const char *id)
{
printf("Requesting vCard from %s.\n", to);
xmpp_send_raw_string(conn, "<iq from='%s' to='%s' type='get' id='%s'>"
xmpp_send_raw_string(conn,
"<iq from='%s' to='%s' type='get' id='%s'>"
"<vCard xmlns='vcard-temp'/></iq>",
xmpp_conn_get_bound_jid(conn), to, id);
}
@@ -253,7 +250,8 @@ int main(int argc, char **argv)
if (argc < 4 || argc > 5) {
prog = argc > 0 ? strdup(argv[0]) : NULL;
printf("Usage: %s <login-jid> <password> <recipient-jid> "
"[image-file]\n\n", prog == NULL ? "vcard" : basename(prog));
"[image-file]\n\n",
prog == NULL ? "vcard" : basename(prog));
printf("If vCard contains a photo it will be stored to "
"image-file. If you don't provide the image-file "
"default filename will be generated.\n");
@@ -281,4 +279,3 @@ int main(int argc, char **argv)
return 0;
}

131
src/auth.c
View File

@@ -89,8 +89,7 @@ static char *_make_scram_sha1_init_msg(xmpp_conn_t * const conn);
static int _handle_missing_features_sasl(xmpp_conn_t *const conn,
void *const userdata);
static int _handle_missing_bind(xmpp_conn_t * const conn,
void * const userdata);
static int _handle_missing_bind(xmpp_conn_t *const conn, void *const userdata);
static int _handle_bind(xmpp_conn_t *const conn,
xmpp_stanza_t *const stanza,
void *const userdata);
@@ -119,7 +118,8 @@ static int _handle_error(xmpp_conn_t * const conn,
}
/* create stream error structure */
conn->stream_error = (xmpp_stream_error_t *)xmpp_alloc(conn->ctx, sizeof(xmpp_stream_error_t));
conn->stream_error = (xmpp_stream_error_t *)xmpp_alloc(
conn->ctx, sizeof(xmpp_stream_error_t));
conn->stream_error->text = NULL;
conn->stream_error->type = XMPP_SE_UNDEFINED_CONDITION;
@@ -208,8 +208,6 @@ static int _handle_missing_features(xmpp_conn_t * const conn,
return 0;
}
static int _handle_features(xmpp_conn_t *const conn,
xmpp_stanza_t *const stanza,
void *const userdata)
@@ -240,7 +238,8 @@ static int _handle_features(xmpp_conn_t * const conn,
if (child && ns && strcmp(ns, XMPP_NS_SASL) == 0) {
for (mech = xmpp_stanza_get_children(child); mech;
mech = xmpp_stanza_get_next(mech)) {
if (xmpp_stanza_get_name(mech) && strcmp(xmpp_stanza_get_name(mech), "mechanism") == 0) {
if (xmpp_stanza_get_name(mech) &&
strcmp(xmpp_stanza_get_name(mech), "mechanism") == 0) {
text = xmpp_stanza_get_text(mech);
if (text == NULL)
continue;
@@ -276,7 +275,8 @@ static char *_get_authid(xmpp_conn_t * const conn)
if (conn->type == XMPP_CLIENT) {
/* authid is the node portion of jid */
if (!conn->jid) return NULL;
if (!conn->jid)
return NULL;
authid = xmpp_jid_node(conn->ctx, conn->jid);
}
@@ -317,8 +317,7 @@ static int _handle_sasl_result(xmpp_conn_t * const conn,
/* 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);
xmpp_debug(conn->ctx, "xmpp", "SASL %s auth failed", (char *)userdata);
/* fall back to next auth method */
_auth(conn);
@@ -334,8 +333,10 @@ static int _handle_sasl_result(xmpp_conn_t * const conn,
conn_open_stream(conn);
} else {
/* got unexpected reply */
xmpp_error(conn->ctx, "xmpp", "Got unexpected reply to SASL %s"\
"authentication.", (char *)userdata);
xmpp_error(conn->ctx, "xmpp",
"Got unexpected reply to SASL %s"
"authentication.",
(char *)userdata);
xmpp_disconnect(conn);
}
@@ -353,8 +354,8 @@ static int _handle_digestmd5_challenge(xmpp_conn_t * const conn,
const char *name;
name = xmpp_stanza_get_name(stanza);
xmpp_debug(conn->ctx, "xmpp",\
"handle digest-md5 (challenge) called for %s", name);
xmpp_debug(conn->ctx, "xmpp", "handle digest-md5 (challenge) called for %s",
name);
if (strcmp(name, "challenge") == 0) {
text = xmpp_stanza_get_text(stanza);
@@ -385,8 +386,8 @@ static int _handle_digestmd5_challenge(xmpp_conn_t * const conn,
xmpp_stanza_add_child(auth, authdata);
xmpp_stanza_release(authdata);
handler_add(conn, _handle_digestmd5_rspauth,
XMPP_NS_SASL, NULL, NULL, NULL);
handler_add(conn, _handle_digestmd5_rspauth, XMPP_NS_SASL, NULL, NULL,
NULL);
xmpp_send(conn, auth);
xmpp_stanza_release(auth);
@@ -408,9 +409,8 @@ static int _handle_digestmd5_rspauth(xmpp_conn_t * const conn,
const char *name;
name = xmpp_stanza_get_name(stanza);
xmpp_debug(conn->ctx, "xmpp",
"handle digest-md5 (rspauth) called for %s", name);
xmpp_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 +456,8 @@ static int _handle_scram_sha1_challenge(xmpp_conn_t * const conn,
if (!challenge)
goto err;
response = sasl_scram_sha1(conn->ctx, challenge, scram_init,
conn->jid, conn->pass);
response = sasl_scram_sha1(conn->ctx, challenge, scram_init, conn->jid,
conn->pass);
xmpp_free(conn->ctx, challenge);
if (!response)
goto err;
@@ -592,8 +592,8 @@ static void _auth(xmpp_conn_t * const conn)
return;
}
handler_add(conn, _handle_proceedtls_default,
XMPP_NS_TLS, NULL, NULL, NULL);
handler_add(conn, _handle_proceedtls_default, XMPP_NS_TLS, NULL, NULL,
NULL);
xmpp_send(conn, auth);
xmpp_stanza_release(auth);
@@ -605,7 +605,8 @@ static void _auth(xmpp_conn_t * const conn)
}
if (conn->tls_mandatory && !xmpp_conn_is_secured(conn)) {
xmpp_error(conn->ctx, "xmpp", "TLS is not supported, but set as "
xmpp_error(conn->ctx, "xmpp",
"TLS is not supported, but set as "
"mandatory for this connection");
conn_disconnect(conn);
return;
@@ -619,8 +620,8 @@ static void _auth(xmpp_conn_t * const conn)
return;
}
handler_add(conn, _handle_sasl_result, XMPP_NS_SASL,
NULL, NULL, "ANONYMOUS");
handler_add(conn, _handle_sasl_result, XMPP_NS_SASL, NULL, NULL,
"ANONYMOUS");
xmpp_send(conn, auth);
xmpp_stanza_release(auth);
@@ -668,8 +669,8 @@ static void _auth(xmpp_conn_t * const conn)
xmpp_stanza_add_child(auth, authdata);
xmpp_stanza_release(authdata);
handler_add(conn, _handle_scram_sha1_challenge,
XMPP_NS_SASL, NULL, NULL, (void *)scram_init);
handler_add(conn, _handle_scram_sha1_challenge, XMPP_NS_SASL, NULL,
NULL, (void *)scram_init);
xmpp_send(conn, auth);
xmpp_stanza_release(auth);
@@ -681,11 +682,10 @@ static void _auth(xmpp_conn_t * const conn)
if (!auth) {
disconnect_mem_error(conn);
return;
}
handler_add(conn, _handle_digestmd5_challenge,
XMPP_NS_SASL, NULL, NULL, NULL);
handler_add(conn, _handle_digestmd5_challenge, XMPP_NS_SASL, NULL, NULL,
NULL);
xmpp_send(conn, auth);
xmpp_stanza_release(auth);
@@ -720,8 +720,8 @@ static void _auth(xmpp_conn_t * const conn)
xmpp_stanza_add_child(auth, authdata);
xmpp_stanza_release(authdata);
handler_add(conn, _handle_sasl_result,
XMPP_NS_SASL, NULL, NULL, "PLAIN");
handler_add(conn, _handle_sasl_result, XMPP_NS_SASL, NULL, NULL,
"PLAIN");
xmpp_send(conn, auth);
xmpp_stanza_release(auth);
@@ -737,7 +737,6 @@ static void _auth(xmpp_conn_t * const conn)
}
}
/** Set up handlers at stream start.
* This function is called internally to Strophe for handling the opening
* of an XMPP stream. It's called by the parser when a stream is opened
@@ -757,8 +756,8 @@ void auth_handle_open(xmpp_conn_t * const conn)
handler_add(conn, _handle_error, XMPP_NS_STREAMS, "error", NULL, NULL);
/* setup handlers for incoming <stream:features> */
handler_add(conn, _handle_features,
XMPP_NS_STREAMS, "features", NULL, NULL);
handler_add(conn, _handle_features, XMPP_NS_STREAMS, "features", NULL,
NULL);
handler_add_timed(conn, _handle_missing_features, FEATURES_TIMEOUT, NULL);
}
@@ -766,8 +765,8 @@ void auth_handle_open(xmpp_conn_t * const conn)
static void _handle_open_tls(xmpp_conn_t *const conn)
{
/* setup handlers for incoming <stream:features> */
handler_add(conn, _handle_features,
XMPP_NS_STREAMS, "features", NULL, NULL);
handler_add(conn, _handle_features, XMPP_NS_STREAMS, "features", NULL,
NULL);
handler_add_timed(conn, _handle_missing_features, FEATURES_TIMEOUT, NULL);
}
@@ -777,10 +776,10 @@ static void _handle_open_sasl(xmpp_conn_t * const conn)
xmpp_debug(conn->ctx, "xmpp", "Reopened stream successfully.");
/* setup stream:features handlers */
handler_add(conn, _handle_features_sasl,
XMPP_NS_STREAMS, "features", NULL, NULL);
handler_add_timed(conn, _handle_missing_features_sasl,
FEATURES_TIMEOUT, NULL);
handler_add(conn, _handle_features_sasl, XMPP_NS_STREAMS, "features", NULL,
NULL);
handler_add_timed(conn, _handle_missing_features_sasl, FEATURES_TIMEOUT,
NULL);
}
static int _handle_features_sasl(xmpp_conn_t *const conn,
@@ -810,8 +809,8 @@ static int _handle_features_sasl(xmpp_conn_t * const conn,
ns = xmpp_stanza_get_ns(session);
opt = xmpp_stanza_get_child_by_name(session, "optional");
if (!opt)
conn->session_required = ns != NULL &&
strcmp(ns, XMPP_NS_SESSION) == 0;
conn->session_required =
ns != NULL && strcmp(ns, XMPP_NS_SESSION) == 0;
}
/* if bind is required, go ahead and start it */
@@ -820,8 +819,7 @@ static int _handle_features_sasl(xmpp_conn_t * const conn,
/* setup response handlers */
handler_add_id(conn, _handle_bind, "_xmpp_bind1", NULL);
handler_add_timed(conn, _handle_missing_bind,
BIND_TIMEOUT, NULL);
handler_add_timed(conn, _handle_missing_bind, BIND_TIMEOUT, NULL);
/* send bind request */
iq = xmpp_iq_new(conn->ctx, "set", "_xmpp_bind1");
@@ -880,7 +878,8 @@ static int _handle_features_sasl(xmpp_conn_t * const conn,
xmpp_stanza_release(iq);
} else {
/* can't bind, disconnect */
xmpp_error(conn->ctx, "xmpp", "Stream features does not allow "\
xmpp_error(conn->ctx, "xmpp",
"Stream features does not allow "
"resource bind.");
xmpp_disconnect(conn);
}
@@ -891,7 +890,8 @@ static int _handle_features_sasl(xmpp_conn_t * const conn,
static int _handle_missing_features_sasl(xmpp_conn_t *const conn,
void *const userdata)
{
xmpp_error(conn->ctx, "xmpp", "Did not receive stream features "\
xmpp_error(conn->ctx, "xmpp",
"Did not receive stream features "
"after SASL authentication.");
xmpp_disconnect(conn);
return 0;
@@ -917,8 +917,8 @@ static int _handle_bind(xmpp_conn_t * const conn,
xmpp_debug(conn->ctx, "xmpp", "Bind successful.");
if (binding) {
xmpp_stanza_t *jid_stanza = xmpp_stanza_get_child_by_name(binding,
"jid");
xmpp_stanza_t *jid_stanza =
xmpp_stanza_get_child_by_name(binding, "jid");
if (jid_stanza) {
conn->bound_jid = xmpp_stanza_get_text(jid_stanza);
}
@@ -928,8 +928,8 @@ static int _handle_bind(xmpp_conn_t * const conn,
if (conn->session_required) {
/* setup response handlers */
handler_add_id(conn, _handle_session, "_xmpp_session1", NULL);
handler_add_timed(conn, _handle_missing_session,
SESSION_TIMEOUT, NULL);
handler_add_timed(conn, _handle_missing_session, SESSION_TIMEOUT,
NULL);
/* send session request */
iq = xmpp_iq_new(conn->ctx, "set", "_xmpp_session1");
@@ -969,8 +969,7 @@ static int _handle_bind(xmpp_conn_t * const conn,
return 0;
}
static int _handle_missing_bind(xmpp_conn_t * const conn,
void * const userdata)
static int _handle_missing_bind(xmpp_conn_t *const conn, void *const userdata)
{
xmpp_error(conn->ctx, "xmpp", "Server did not reply to bind request.");
xmpp_disconnect(conn);
@@ -1014,10 +1013,10 @@ static int _handle_missing_session(xmpp_conn_t * const conn,
return 0;
}
static int _handle_missing_legacy(xmpp_conn_t * const conn,
void * const userdata)
static int _handle_missing_legacy(xmpp_conn_t *const conn, void *const userdata)
{
xmpp_error(conn->ctx, "xmpp", "Server did not reply to legacy "\
xmpp_error(conn->ctx, "xmpp",
"Server did not reply to legacy "
"authentication request.");
xmpp_disconnect(conn);
return 0;
@@ -1037,7 +1036,8 @@ static int _handle_legacy(xmpp_conn_t * const conn,
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 "\
xmpp_error(conn->ctx, "xmpp",
"Server sent us an unexpected response "
"to legacy authentication request.");
xmpp_disconnect(conn);
} else if (strcmp(type, "error") == 0) {
@@ -1051,7 +1051,8 @@ static int _handle_legacy(xmpp_conn_t * const conn,
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 "\
xmpp_error(conn->ctx, "xmpp",
"Server sent us a legacy authentication "
"response with a bad type.");
xmpp_disconnect(conn);
}
@@ -1160,8 +1161,8 @@ void auth_handle_component_open(xmpp_conn_t * const conn)
handler_reset_timed(conn, 0);
handler_add(conn, _handle_error, XMPP_NS_STREAMS, "error", NULL, NULL);
handler_add(conn, _handle_component_hs_response, NULL,
"handshake", NULL, NULL);
handler_add(conn, _handle_component_hs_response, NULL, "handshake", NULL,
NULL);
handler_add_timed(conn, _handle_missing_handshake, HANDSHAKE_TIMEOUT, NULL);
rc = _handle_component_auth(conn);
@@ -1200,16 +1201,18 @@ int _handle_component_auth(xmpp_conn_t * const 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));
xmpp_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.");
xmpp_debug(conn->ctx, "auth",
"Sent component handshake to the server.");
xmpp_free(conn->ctx, digest);
} else {
xmpp_debug(conn->ctx, "auth", "Couldn't allocate memory for component "\
xmpp_debug(conn->ctx, "auth",
"Couldn't allocate memory for component "
"handshake digest.");
return XMPP_EMEM;
}

9
src/common.h
View File

@@ -19,7 +19,6 @@
#include <stdio.h>
#include <stdarg.h>
#include "strophe.h"
#include "ostypes.h"
#include "sock.h"
@@ -54,11 +53,9 @@ struct _xmpp_ctx_t {
unsigned long timeout;
};
/* convenience functions for accessing the context */
void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size);
void *xmpp_realloc(const xmpp_ctx_t * const ctx, void *p,
const size_t size);
void *xmpp_realloc(const xmpp_ctx_t *const ctx, void *p, const size_t size);
char *xmpp_strdup(const xmpp_ctx_t *const ctx, const char *const s);
void xmpp_log(const xmpp_ctx_t *const ctx,
@@ -226,7 +223,6 @@ int conn_tls_start(xmpp_conn_t * const conn);
void conn_prepare_reset(xmpp_conn_t *const conn, xmpp_open_handler handler);
void conn_parser_reset(xmpp_conn_t *const conn);
typedef enum {
XMPP_STANZA_UNKNOWN,
XMPP_STANZA_TEXT,
@@ -250,8 +246,7 @@ struct _xmpp_stanza_t {
};
/* handler management */
void handler_fire_stanza(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza);
void handler_fire_stanza(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza);
uint64_t handler_fire_timed(xmpp_ctx_t *const ctx);
void handler_reset_timed(xmpp_conn_t *conn, int user_only);
void handler_add_timed(xmpp_conn_t *const conn,

245
src/conn.c
View File

@@ -48,20 +48,21 @@
#define CONNECT_TIMEOUT 5000 /* 5 seconds */
#endif
static int _disconnect_cleanup(xmpp_conn_t * const conn,
void * const userdata);
static int _disconnect_cleanup(xmpp_conn_t *const conn, void *const userdata);
static char *_conn_build_stream_tag(xmpp_conn_t *const conn,
char **attributes, size_t attributes_len);
static void _conn_attributes_new(xmpp_conn_t *conn, char **attrs,
char ***attributes, size_t *attributes_len);
static void _conn_attributes_destroy(xmpp_conn_t *conn, char **attributes,
char **attributes,
size_t attributes_len);
static void _handle_stream_start(char *name, char **attrs,
void * const userdata);
static void _handle_stream_end(char *name,
void * const userdata);
static void _handle_stream_stanza(xmpp_stanza_t *stanza,
void * const userdata);
static void _conn_attributes_new(xmpp_conn_t *conn,
char **attrs,
char ***attributes,
size_t *attributes_len);
static void _conn_attributes_destroy(xmpp_conn_t *conn,
char **attributes,
size_t attributes_len);
static void
_handle_stream_start(char *name, char **attrs, void *const userdata);
static void _handle_stream_end(char *name, void *const userdata);
static void _handle_stream_stanza(xmpp_stanza_t *stanza, void *const userdata);
static unsigned short _conn_default_port(xmpp_conn_t *const conn,
xmpp_conn_type_t type);
static void _conn_reset(xmpp_conn_t *const conn);
@@ -73,7 +74,9 @@ static int _conn_connect(xmpp_conn_t * const conn,
xmpp_conn_handler callback,
void *const userdata);
void xmpp_send_error(xmpp_conn_t * const conn, xmpp_error_type_t const type, char * const text)
void xmpp_send_error(xmpp_conn_t *const conn,
xmpp_error_type_t const type,
char *const text)
{
xmpp_stanza_t *error = xmpp_error_new(conn->ctx, type, text);
@@ -95,7 +98,8 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
xmpp_conn_t *conn = NULL;
xmpp_connlist_t *tail, *item;
if (ctx == NULL) return NULL;
if (ctx == NULL)
return NULL;
conn = xmpp_alloc(ctx, sizeof(xmpp_conn_t));
if (conn != NULL) {
@@ -146,11 +150,9 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
conn->bind_required = 0;
conn->session_required = 0;
conn->parser = parser_new(conn->ctx,
_handle_stream_start,
_handle_stream_end,
_handle_stream_stanza,
conn);
conn->parser =
parser_new(conn->ctx, _handle_stream_start, _handle_stream_end,
_handle_stream_stanza, conn);
conn->reset_parser = 0;
conn->authenticated = 0;
@@ -166,7 +168,8 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
/* add connection to ctx->connlist */
tail = conn->ctx->connlist;
while (tail && tail->next) tail = tail->next;
while (tail && tail->next)
tail = tail->next;
item = xmpp_alloc(conn->ctx, sizeof(xmpp_connlist_t));
if (!item) {
@@ -179,8 +182,10 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
item->conn = conn;
item->next = NULL;
if (tail) tail->next = item;
else conn->ctx->connlist = item;
if (tail)
tail->next = item;
else
conn->ctx->connlist = item;
}
}
@@ -255,8 +260,7 @@ int xmpp_conn_release(xmpp_conn_t * const conn)
ctx = conn->ctx;
if (conn->state == XMPP_STATE_CONNECTING ||
conn->state == XMPP_STATE_CONNECTED)
{
conn->state == XMPP_STATE_CONNECTED) {
conn_disconnect(conn);
}
@@ -317,17 +321,23 @@ int xmpp_conn_release(xmpp_conn_t * const conn)
thli = hlitem;
hlitem = hlitem->next;
if (thli->u.ns) xmpp_free(ctx, thli->u.ns);
if (thli->u.name) xmpp_free(ctx, thli->u.name);
if (thli->u.type) xmpp_free(ctx, thli->u.type);
if (thli->u.ns)
xmpp_free(ctx, thli->u.ns);
if (thli->u.name)
xmpp_free(ctx, thli->u.name);
if (thli->u.type)
xmpp_free(ctx, thli->u.type);
xmpp_free(ctx, thli);
}
parser_free(conn->parser);
if (conn->jid) xmpp_free(ctx, conn->jid);
if (conn->pass) xmpp_free(ctx, conn->pass);
if (conn->lang) xmpp_free(ctx, conn->lang);
if (conn->jid)
xmpp_free(ctx, conn->jid);
if (conn->pass)
xmpp_free(ctx, conn->pass);
if (conn->lang)
xmpp_free(ctx, conn->lang);
xmpp_free(ctx, conn);
released = 1;
}
@@ -379,7 +389,8 @@ const char *xmpp_conn_get_bound_jid(const xmpp_conn_t * const conn)
*/
void xmpp_conn_set_jid(xmpp_conn_t *const conn, const char *const jid)
{
if (conn->jid) xmpp_free(conn->ctx, conn->jid);
if (conn->jid)
xmpp_free(conn->ctx, conn->jid);
conn->jid = xmpp_strdup(conn->ctx, jid);
}
@@ -407,7 +418,8 @@ const char *xmpp_conn_get_pass(const xmpp_conn_t * const conn)
*/
void xmpp_conn_set_pass(xmpp_conn_t *const conn, const char *const pass)
{
if (conn->pass) xmpp_free(conn->ctx, conn->pass);
if (conn->pass)
xmpp_free(conn->ctx, conn->pass);
conn->pass = xmpp_strdup(conn->ctx, pass);
}
@@ -459,7 +471,8 @@ int xmpp_connect_client(xmpp_conn_t * const conn,
int rc;
domain = xmpp_jid_domain(conn->ctx, conn->jid);
if (!domain) return XMPP_EMEM;
if (!domain)
return XMPP_EMEM;
if (altdomain != NULL) {
xmpp_debug(conn->ctx, "xmpp", "Connecting via altdomain.");
@@ -475,7 +488,8 @@ int xmpp_connect_client(xmpp_conn_t * const conn,
}
if (XMPP_DOMAIN_NOT_FOUND == found) {
xmpp_debug(conn->ctx, "xmpp", "SRV lookup failed, "
xmpp_debug(conn->ctx, "xmpp",
"SRV lookup failed, "
"connecting via domain.");
host = domain;
port = altport ? altport : _conn_default_port(conn, XMPP_CLIENT);
@@ -489,8 +503,8 @@ int xmpp_connect_client(xmpp_conn_t * const conn,
port = rr->port;
rr = rr->next;
}
rc = _conn_connect(conn, domain, host, port, XMPP_CLIENT,
callback, userdata);
rc = _conn_connect(conn, domain, host, port, XMPP_CLIENT, callback,
userdata);
} while (rc != 0 && rr != NULL);
xmpp_free(conn->ctx, domain);
@@ -522,17 +536,21 @@ int xmpp_connect_client(xmpp_conn_t * const conn,
*
* @ingroup Connections
*/
int xmpp_connect_component(xmpp_conn_t * const conn, const char * const server,
unsigned short port, xmpp_conn_handler callback,
int xmpp_connect_component(xmpp_conn_t *const conn,
const char *const server,
unsigned short port,
xmpp_conn_handler callback,
void *const userdata)
{
/* The server domain, jid and password MUST be specified. */
if (!(server && conn->jid && conn->pass)) return XMPP_EINVOP;
if (!(server && conn->jid && conn->pass))
return XMPP_EINVOP;
/* XEP-0114 does not support TLS */
xmpp_conn_disable_tls(conn);
if (!conn->tls_disabled) {
xmpp_error(conn->ctx, "conn", "Failed to disable TLS. "
xmpp_error(conn->ctx, "conn",
"Failed to disable TLS. "
"XEP-0114 does not support TLS");
return XMPP_EINT;
}
@@ -591,7 +609,8 @@ void conn_established(xmpp_conn_t * const conn)
/* we skip authentication for a "raw" connection, but the event loop
ignores user's handlers when conn->authenticated is not set. */
conn->authenticated = 1;
conn->conn_handler(conn, XMPP_CONN_RAW_CONNECT, 0, NULL, conn->userdata);
conn->conn_handler(conn, XMPP_CONN_RAW_CONNECT, 0, NULL,
conn->userdata);
} else {
/* send stream init */
conn_open_stream(conn);
@@ -636,7 +655,8 @@ int xmpp_conn_open_stream_default(xmpp_conn_t * const conn)
*
* @ingroup Connections
*/
int xmpp_conn_open_stream(xmpp_conn_t * const conn, char **attributes,
int xmpp_conn_open_stream(xmpp_conn_t *const conn,
char **attributes,
size_t attributes_len)
{
char *tag;
@@ -736,8 +756,7 @@ void xmpp_disconnect(xmpp_conn_t * const conn)
xmpp_send_raw_string(conn, "</stream:stream>");
/* setup timed handler in case disconnect takes too long */
handler_add_timed(conn, _disconnect_cleanup,
DISCONNECT_TIMEOUT, NULL);
handler_add_timed(conn, _disconnect_cleanup, DISCONNECT_TIMEOUT, NULL);
}
/** Send a raw string to the XMPP server.
@@ -753,8 +772,7 @@ void xmpp_disconnect(xmpp_conn_t * const conn)
*
* @ingroup Connections
*/
void xmpp_send_raw_string(xmpp_conn_t * const conn,
const char * const fmt, ...)
void xmpp_send_raw_string(xmpp_conn_t *const conn, const char *const fmt, ...)
{
va_list ap;
size_t len;
@@ -771,7 +789,8 @@ void xmpp_send_raw_string(xmpp_conn_t * const conn,
len++; /* account for trailing \0 */
bigbuf = xmpp_alloc(conn->ctx, len);
if (!bigbuf) {
xmpp_debug(conn->ctx, "xmpp", "Could not allocate memory for send_raw_string");
xmpp_debug(conn->ctx, "xmpp",
"Could not allocate memory for send_raw_string");
return;
}
va_start(ap, fmt);
@@ -803,15 +822,18 @@ void xmpp_send_raw_string(xmpp_conn_t * const conn,
* @ingroup Connections
*/
void xmpp_send_raw(xmpp_conn_t *const conn,
const char * const data, const size_t len)
const char *const data,
const size_t len)
{
xmpp_send_queue_t *item;
if (conn->state != XMPP_STATE_CONNECTED) return;
if (conn->state != XMPP_STATE_CONNECTED)
return;
/* create send queue item for queue */
item = xmpp_alloc(conn->ctx, sizeof(xmpp_send_queue_t));
if (!item) return;
if (!item)
return;
item->data = xmpp_alloc(conn->ctx, len);
if (!item->data) {
@@ -845,8 +867,7 @@ void xmpp_send_raw(xmpp_conn_t * const conn,
*
* @ingroup Connections
*/
void xmpp_send(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza)
void xmpp_send(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza)
{
char *buf;
size_t len;
@@ -869,16 +890,15 @@ void xmpp_send(xmpp_conn_t * const conn,
void conn_open_stream(xmpp_conn_t *const conn)
{
xmpp_send_raw_string(conn,
"<?xml version=\"1.0\"?>" \
"<stream:stream to=\"%s\" " \
"xml:lang=\"%s\" " \
"version=\"1.0\" " \
"xmlns=\"%s\" " \
"<?xml version=\"1.0\"?>"
"<stream:stream to=\"%s\" "
"xml:lang=\"%s\" "
"version=\"1.0\" "
"xmlns=\"%s\" "
"xmlns:stream=\"%s\">",
conn->domain,
conn->lang,
conn->type == XMPP_CLIENT ? XMPP_NS_CLIENT :
XMPP_NS_COMPONENT,
conn->domain, conn->lang,
conn->type == XMPP_CLIENT ? XMPP_NS_CLIENT
: XMPP_NS_COMPONENT,
XMPP_NS_STREAMS);
}
@@ -906,8 +926,10 @@ int conn_tls_start(xmpp_conn_t * const conn)
}
}
if (rc != 0) {
xmpp_debug(conn->ctx, "conn", "Couldn't start TLS! "
"error %d tls_error %d", rc, conn->error);
xmpp_debug(conn->ctx, "conn",
"Couldn't start TLS! "
"error %d tls_error %d",
rc, conn->error);
}
return rc;
}
@@ -928,7 +950,8 @@ long xmpp_conn_get_flags(const xmpp_conn_t * const conn)
XMPP_CONN_FLAG_MANDATORY_TLS * conn->tls_mandatory |
XMPP_CONN_FLAG_LEGACY_SSL * conn->tls_legacy_ssl |
XMPP_CONN_FLAG_TRUST_TLS * conn->tls_trust |
XMPP_CONN_FLAG_LEGACY_AUTH * conn->auth_legacy_enabled;;
XMPP_CONN_FLAG_LEGACY_AUTH * conn->auth_legacy_enabled;
;
return flags;
}
@@ -958,7 +981,8 @@ long xmpp_conn_get_flags(const xmpp_conn_t * const conn)
int xmpp_conn_set_flags(xmpp_conn_t *const conn, long flags)
{
if (conn->state != XMPP_STATE_DISCONNECTED) {
xmpp_error(conn->ctx, "conn", "Flags can be set only "
xmpp_error(conn->ctx, "conn",
"Flags can be set only "
"for disconnected connection");
return XMPP_EINVOP;
}
@@ -1038,13 +1062,10 @@ int xmpp_conn_is_disconnected(xmpp_conn_t * const conn)
return conn->state == XMPP_STATE_DISCONNECTED ? 1 : 0;
}
/* timed handler for cleanup if normal disconnect procedure takes too long */
static int _disconnect_cleanup(xmpp_conn_t * const conn,
void * const userdata)
static int _disconnect_cleanup(xmpp_conn_t *const conn, void *const userdata)
{
xmpp_debug(conn->ctx, "xmpp",
"disconnection forced by cleanup timeout");
xmpp_debug(conn->ctx, "xmpp", "disconnection forced by cleanup timeout");
conn_disconnect(conn);
@@ -1052,7 +1073,8 @@ static int _disconnect_cleanup(xmpp_conn_t * const conn,
}
static char *_conn_build_stream_tag(xmpp_conn_t *const conn,
char **attributes, size_t attributes_len)
char **attributes,
size_t attributes_len)
{
char *tag;
size_t len;
@@ -1068,7 +1090,8 @@ static char *_conn_build_stream_tag(xmpp_conn_t * const conn,
for (i = 0; i < attributes_len; ++i)
len += strlen(attributes[i]) + 2;
tag = xmpp_alloc(conn->ctx, len + 1);
if (!tag) return NULL;
if (!tag)
return NULL;
strcpy(tag, tag_head);
for (i = 0; i < attributes_len; ++i) {
@@ -1084,7 +1107,8 @@ static char *_conn_build_stream_tag(xmpp_conn_t * const conn,
strcat(tag, tag_tail);
if (strlen(tag) != len) {
xmpp_error(conn->ctx, "xmpp", "Internal error in "
xmpp_error(conn->ctx, "xmpp",
"Internal error in "
"_conn_build_stream_tag().");
xmpp_free(conn->ctx, tag);
tag = NULL;
@@ -1093,20 +1117,24 @@ static char *_conn_build_stream_tag(xmpp_conn_t * const conn,
return tag;
}
static void _conn_attributes_new(xmpp_conn_t *conn, char **attrs,
char ***attributes, size_t *attributes_len)
static void _conn_attributes_new(xmpp_conn_t *conn,
char **attrs,
char ***attributes,
size_t *attributes_len)
{
char **array = NULL;
size_t nr = 0;
size_t i;
if (attrs) {
for (; attrs[nr]; ++nr);
for (; attrs[nr]; ++nr)
;
array = xmpp_alloc(conn->ctx, sizeof(*array) * nr);
for (i = 0; array && i < nr; ++i) {
array[i] = (i & 1) == 0 ? parser_attr_name(conn->ctx, attrs[i])
: xmpp_strdup(conn->ctx, attrs[i]);
if (array[i] == NULL) break;
if (array[i] == NULL)
break;
}
if (!array || i < nr) {
xmpp_error(conn->ctx, "xmpp", "Memory allocation error.");
@@ -1119,7 +1147,8 @@ static void _conn_attributes_new(xmpp_conn_t *conn, char **attrs,
*attributes_len = nr;
}
static void _conn_attributes_destroy(xmpp_conn_t *conn, char **attributes,
static void _conn_attributes_destroy(xmpp_conn_t *conn,
char **attributes,
size_t attributes_len)
{
size_t i;
@@ -1150,7 +1179,8 @@ static char *_get_stream_attribute(char **attrs, char *name)
{
int i;
if (!attrs) return NULL;
if (!attrs)
return NULL;
for (i = 0; attrs[i]; i += 2)
if (strcmp(name, attrs[i]) == 0)
@@ -1159,14 +1189,14 @@ static char *_get_stream_attribute(char **attrs, char *name)
return NULL;
}
static void _handle_stream_start(char *name, char **attrs,
void * const userdata)
static void _handle_stream_start(char *name, char **attrs, void *const userdata)
{
xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
char *id;
int failed = 0;
if (conn->stream_id) xmpp_free(conn->ctx, conn->stream_id);
if (conn->stream_id)
xmpp_free(conn->ctx, conn->stream_id);
conn->stream_id = NULL;
if (strcmp(name, "stream") == 0) {
@@ -1180,8 +1210,10 @@ static void _handle_stream_start(char *name, char **attrs,
failed = 1;
}
} else {
xmpp_error(conn->ctx, "conn", "Server did not open valid stream."
" name = %s.", name);
xmpp_error(conn->ctx, "conn",
"Server did not open valid stream."
" name = %s.",
name);
failed = 1;
}
@@ -1193,8 +1225,7 @@ static void _handle_stream_start(char *name, char **attrs,
}
}
static void _handle_stream_end(char *name,
void * const userdata)
static void _handle_stream_end(char *name, void *const userdata)
{
xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
@@ -1203,8 +1234,7 @@ static void _handle_stream_end(char *name,
conn_disconnect_clean(conn);
}
static void _handle_stream_stanza(xmpp_stanza_t *stanza,
void * const userdata)
static void _handle_stream_stanza(xmpp_stanza_t *stanza, void *const userdata)
{
xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
char *buf;
@@ -1223,8 +1253,8 @@ static unsigned short _conn_default_port(xmpp_conn_t * const conn,
{
switch (type) {
case XMPP_CLIENT:
return conn->tls_legacy_ssl ? XMPP_PORT_CLIENT_LEGACY_SSL :
XMPP_PORT_CLIENT;
return conn->tls_legacy_ssl ? XMPP_PORT_CLIENT_LEGACY_SSL
: XMPP_PORT_CLIENT;
case XMPP_COMPONENT:
return XMPP_PORT_COMPONENT;
default:
@@ -1262,9 +1292,12 @@ static void _conn_reset(xmpp_conn_t * const conn)
conn->stream_error = NULL;
}
if (conn->domain) xmpp_free(ctx, conn->domain);
if (conn->bound_jid) xmpp_free(ctx, conn->bound_jid);
if (conn->stream_id) xmpp_free(ctx, conn->stream_id);
if (conn->domain)
xmpp_free(ctx, conn->domain);
if (conn->bound_jid)
xmpp_free(ctx, conn->bound_jid);
if (conn->stream_id)
xmpp_free(ctx, conn->stream_id);
conn->domain = NULL;
conn->bound_jid = NULL;
conn->stream_id = NULL;
@@ -1290,20 +1323,25 @@ static int _conn_connect(xmpp_conn_t * const conn,
{
xmpp_open_handler open_handler;
if (conn->state != XMPP_STATE_DISCONNECTED) return XMPP_EINVOP;
if (type != XMPP_CLIENT && type != XMPP_COMPONENT) return XMPP_EINVOP;
if (host == NULL || port == 0) return XMPP_EINT;
if (conn->state != XMPP_STATE_DISCONNECTED)
return XMPP_EINVOP;
if (type != XMPP_CLIENT && type != XMPP_COMPONENT)
return XMPP_EINVOP;
if (host == NULL || port == 0)
return XMPP_EINT;
_conn_reset(conn);
conn->type = type;
conn->domain = xmpp_strdup(conn->ctx, domain);
if (!conn->domain) return XMPP_EMEM;
if (!conn->domain)
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);
if (conn->sock == -1) return XMPP_EINT;
xmpp_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)
sock_set_keepalive(conn->sock, conn->ka_timeout, conn->ka_interval);
@@ -1311,9 +1349,10 @@ static int _conn_connect(xmpp_conn_t * const conn,
conn->conn_handler = callback;
conn->userdata = userdata;
open_handler = conn->is_raw ? auth_handle_open_stub :
type == XMPP_CLIENT ? auth_handle_open :
auth_handle_component_open;
open_handler = conn->is_raw
? auth_handle_open_stub
: type == XMPP_CLIENT ? auth_handle_open
: auth_handle_component_open;
conn_prepare_reset(conn, open_handler);
/* FIXME: it could happen that the connect returns immediately as

126
src/crypto.c
View File

@@ -91,7 +91,8 @@ char *xmpp_sha1(xmpp_ctx_t *ctx, const unsigned char *data, size_t len)
*
* @ingroup Digests
*/
void xmpp_sha1_digest(const unsigned char *data, size_t len,
void xmpp_sha1_digest(const unsigned char *data,
size_t len,
unsigned char *digest)
{
crypto_SHA1((const uint8_t *)data, len, digest);
@@ -214,43 +215,34 @@ void xmpp_sha1_to_digest(xmpp_sha1_t *sha1, unsigned char *digest)
memcpy(digest, sha1->digest, SHA1_DIGEST_SIZE);
}
/* Base64 encoding routines. Implemented according to RFC 3548. */
/* map of all byte values to the base64 values, or to
'65' which indicates an invalid character. '=' is '64' */
static const unsigned char _base64_invcharmap[256] = {
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,62, 65,65,65,63,
52,53,54,55, 56,57,58,59, 60,61,65,65, 65,64,65,65,
65, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,
15,16,17,18, 19,20,21,22, 23,24,25,65, 65,65,65,65,
65,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
41,42,43,44, 45,46,47,48, 49,50,51,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65
};
65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 62, 65, 65, 65, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
61, 65, 65, 65, 64, 65, 65, 65, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 65, 65, 65, 65,
65, 65, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
65, 65, 65, 65, 65, 65, 65, 65, 65};
/* map of all 6-bit values to their corresponding byte
in the base64 alphabet. Padding char is the value '64' */
static const char _base64_charmap[65] = {
'A','B','C','D', 'E','F','G','H',
'I','J','K','L', 'M','N','O','P',
'Q','R','S','T', 'U','V','W','X',
'Y','Z','a','b', 'c','d','e','f',
'g','h','i','j', 'k','l','m','n',
'o','p','q','r', 's','t','u','v',
'w','x','y','z', '0','1','2','3',
'4','5','6','7', '8','9','+','/',
'='
};
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '='};
static size_t base64_encoded_len(const size_t len)
{
@@ -259,7 +251,8 @@ static size_t base64_encoded_len(const size_t len)
}
static char *base64_encode(xmpp_ctx_t *ctx,
const unsigned char * const buffer, const size_t len)
const unsigned char *const buffer,
const size_t len)
{
size_t clen;
char *cbuf, *c;
@@ -317,24 +310,31 @@ static size_t base64_decoded_len(const char * const buffer, const size_t len)
unsigned char c;
size_t i;
if (len < 4) return 0;
if (len < 4)
return 0;
/* count the padding characters for the remainder */
for (i = len; i > 0; --i) {
c = _base64_invcharmap[(unsigned char)buffer[i - 1]];
if (c < 64) break;
if (c == 64) ++nudge;
if (c > 64) return 0;
if (c < 64)
break;
if (c == 64)
++nudge;
if (c > 64)
return 0;
}
if (nudge > 2) return 0;
if (nudge > 2)
return 0;
/* decoded steam is 3 bytes for every four */
return 3 * (len >> 2) - nudge;
}
static void base64_decode(xmpp_ctx_t *ctx,
const char * const buffer, const size_t len,
unsigned char **out, size_t *outlen)
const char *const buffer,
const size_t len,
unsigned char **out,
size_t *outlen)
{
size_t dlen;
unsigned char *dbuf, *d;
@@ -342,10 +342,12 @@ static void base64_decode(xmpp_ctx_t *ctx,
size_t i;
/* len must be a multiple of 4 */
if (len & 0x03) goto _base64_error;
if (len & 0x03)
goto _base64_error;
dlen = base64_decoded_len(buffer, len);
if (dlen == 0) goto _base64_error;
if (dlen == 0)
goto _base64_error;
dbuf = xmpp_alloc(ctx, dlen + 1);
if (dbuf != NULL) {
@@ -353,22 +355,27 @@ static void base64_decode(xmpp_ctx_t *ctx,
/* loop over each set of 4 characters, decoding 3 bytes */
for (i = 0; i + 3 < len; i += 4) {
hextet = _base64_invcharmap[(unsigned char)buffer[i]];
if (hextet & 0xC0) break;
if (hextet & 0xC0)
break;
word = hextet << 18;
hextet = _base64_invcharmap[(unsigned char)buffer[i + 1]];
if (hextet & 0xC0) break;
if (hextet & 0xC0)
break;
word |= hextet << 12;
hextet = _base64_invcharmap[(unsigned char)buffer[i + 2]];
if (hextet & 0xC0) break;
if (hextet & 0xC0)
break;
word |= hextet << 6;
hextet = _base64_invcharmap[(unsigned char)buffer[i + 3]];
if (hextet & 0xC0) break;
if (hextet & 0xC0)
break;
word |= hextet;
*d++ = (word & 0x00FF0000) >> 16;
*d++ = (word & 0x0000FF00) >> 8;
*d++ = (word & 0x000000FF);
}
if (hextet > 64) goto _base64_decode_error;
if (hextet > 64)
goto _base64_decode_error;
/* handle the remainder */
switch (dlen % 3) {
case 0:
@@ -377,32 +384,40 @@ static void base64_decode(xmpp_ctx_t *ctx,
case 1:
/* redo the last quartet, checking for correctness */
hextet = _base64_invcharmap[(unsigned char)buffer[len - 4]];
if (hextet & 0xC0) goto _base64_decode_error;
if (hextet & 0xC0)
goto _base64_decode_error;
word = hextet << 2;
hextet = _base64_invcharmap[(unsigned char)buffer[len - 3]];
if (hextet & 0xC0) goto _base64_decode_error;
if (hextet & 0xC0)
goto _base64_decode_error;
word |= hextet >> 4;
*d++ = word & 0xFF;
hextet = _base64_invcharmap[(unsigned char)buffer[len - 2]];
if (hextet != 64) goto _base64_decode_error;
if (hextet != 64)
goto _base64_decode_error;
hextet = _base64_invcharmap[(unsigned char)buffer[len - 1]];
if (hextet != 64) goto _base64_decode_error;
if (hextet != 64)
goto _base64_decode_error;
break;
case 2:
/* redo the last quartet, checking for correctness */
hextet = _base64_invcharmap[(unsigned char)buffer[len - 4]];
if (hextet & 0xC0) goto _base64_decode_error;
if (hextet & 0xC0)
goto _base64_decode_error;
word = hextet << 10;
hextet = _base64_invcharmap[(unsigned char)buffer[len - 3]];
if (hextet & 0xC0) goto _base64_decode_error;
if (hextet & 0xC0)
goto _base64_decode_error;
word |= hextet << 4;
hextet = _base64_invcharmap[(unsigned char)buffer[len - 2]];
if (hextet & 0xC0) goto _base64_decode_error;
if (hextet & 0xC0)
goto _base64_decode_error;
word |= hextet >> 2;
*d++ = (word & 0xFF00) >> 8;
*d++ = (word & 0x00FF);
hextet = _base64_invcharmap[(unsigned char)buffer[len - 1]];
if (hextet != 64) goto _base64_decode_error;
if (hextet != 64)
goto _base64_decode_error;
break;
}
*d = '\0';
@@ -484,8 +499,11 @@ char *xmpp_base64_decode_str(xmpp_ctx_t *ctx, const char *base64, size_t len)
*
* @ingroup Encodings
*/
void xmpp_base64_decode_bin(xmpp_ctx_t *ctx, const char *base64, size_t len,
unsigned char **out, size_t *outlen)
void xmpp_base64_decode_bin(xmpp_ctx_t *ctx,
const char *base64,
size_t len,
unsigned char **out,
size_t *outlen)
{
base64_decode(ctx, base64, len, out, outlen);
}

36
src/ctx.c
View File

@@ -113,8 +113,7 @@ void xmpp_shutdown(void)
*/
int xmpp_version_check(int major, int minor)
{
return (major == LIBXMPP_VERSION_MAJOR) &&
(minor >= LIBXMPP_VERSION_MINOR);
return (major == LIBXMPP_VERSION_MAJOR) && (minor >= LIBXMPP_VERSION_MINOR);
}
/* We define the global default allocator, logger, and context here. */
@@ -140,17 +139,13 @@ static void *_realloc(void *p, const size_t size, void * const userdata)
/* default memory function map */
static xmpp_mem_t xmpp_default_mem = {
_malloc, /* use the thinly wrapped stdlib routines by default */
_free,
_realloc,
NULL
};
_free, _realloc, NULL};
/* log levels and names */
static const char * const _xmpp_log_level_name[4] = {"DEBUG", "INFO", "WARN", "ERROR"};
static const xmpp_log_level_t _xmpp_default_logger_levels[] = {XMPP_LEVEL_DEBUG,
XMPP_LEVEL_INFO,
XMPP_LEVEL_WARN,
XMPP_LEVEL_ERROR};
static const char *const _xmpp_log_level_name[4] = {"DEBUG", "INFO", "WARN",
"ERROR"};
static const xmpp_log_level_t _xmpp_default_logger_levels[] = {
XMPP_LEVEL_DEBUG, XMPP_LEVEL_INFO, XMPP_LEVEL_WARN, XMPP_LEVEL_ERROR};
/** Log a message.
* The default logger writes to stderr.
@@ -172,11 +167,14 @@ static void xmpp_default_logger(void * const userdata,
}
static const xmpp_log_t _xmpp_default_loggers[] = {
{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_DEBUG]},
{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_INFO]},
{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_WARN]},
{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_ERROR]}
};
{&xmpp_default_logger,
(void *)&_xmpp_default_logger_levels[XMPP_LEVEL_DEBUG]},
{&xmpp_default_logger,
(void *)&_xmpp_default_logger_levels[XMPP_LEVEL_INFO]},
{&xmpp_default_logger,
(void *)&_xmpp_default_logger_levels[XMPP_LEVEL_WARN]},
{&xmpp_default_logger,
(void *)&_xmpp_default_logger_levels[XMPP_LEVEL_ERROR]}};
/** Get a default logger with filtering.
* The default logger provides a basic logging setup which writes log
@@ -192,7 +190,8 @@ static const xmpp_log_t _xmpp_default_loggers[] = {
xmpp_log_t *xmpp_get_default_logger(xmpp_log_level_t level)
{
/* clamp to the known range */
if (level > XMPP_LEVEL_ERROR) level = XMPP_LEVEL_ERROR;
if (level > XMPP_LEVEL_ERROR)
level = XMPP_LEVEL_ERROR;
return (xmpp_log_t *)&_xmpp_default_loggers[level];
}
@@ -234,8 +233,7 @@ void xmpp_free(const xmpp_ctx_t * const ctx, void *p)
*
* @return a pointer to the reallocated memory or NULL on an error
*/
void *xmpp_realloc(const xmpp_ctx_t * const ctx, void *p,
const size_t size)
void *xmpp_realloc(const xmpp_ctx_t *const ctx, void *p, const size_t size)
{
return ctx->mem->realloc(p, size, ctx->mem->userdata);
}

29
src/event.c
View File

@@ -88,7 +88,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
uint64_t usec;
int tls_read_bytes = 0;
if (ctx->loop_status == XMPP_LOOP_QUIT) return;
if (ctx->loop_status == XMPP_LOOP_QUIT)
return;
/* send queued data */
connitem = ctx->connlist;
@@ -141,7 +142,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
/* pop the top item */
conn->send_queue_head = sq;
/* if we've sent everything update the tail */
if (!sq) conn->send_queue_tail = NULL;
if (!sq)
conn->send_queue_tail = NULL;
}
/* tear down connection on error */
@@ -162,7 +164,6 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
conn_parser_reset(connitem->conn);
}
/* fire any ready timed handlers, then make sure we don't wait past
the time when timed handlers need to be called */
next = handler_fire_timed(ctx);
@@ -233,7 +234,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
}
/* no events happened */
if (ret == 0 && tls_read_bytes == 0) return;
if (ret == 0 && tls_read_bytes == 0)
return;
/* process events */
connitem = ctx->connlist;
@@ -261,29 +263,35 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
break;
case XMPP_STATE_CONNECTED:
if (FD_ISSET(conn->sock, &rfds) || (conn->tls && tls_pending(conn->tls))) {
if (FD_ISSET(conn->sock, &rfds) ||
(conn->tls && tls_pending(conn->tls))) {
if (conn->tls) {
ret = tls_read(conn->tls, buf, STROPE_MESSAGE_BUFFER_SIZE);
} else {
ret = sock_read(conn->sock, buf, STROPE_MESSAGE_BUFFER_SIZE);
ret =
sock_read(conn->sock, buf, STROPE_MESSAGE_BUFFER_SIZE);
}
if (ret > 0) {
ret = parser_feed(conn->parser, buf, ret);
if (!ret) {
xmpp_debug(ctx, "xmpp", "parse error [%s]", buf);
xmpp_send_error(conn, XMPP_SE_INVALID_XML, "parse error");
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));
xmpp_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.");
xmpp_debug(ctx, "xmpp",
"Socket closed by remote host.");
conn->error = ECONNRESET;
conn_disconnect(conn);
}
@@ -314,7 +322,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
*/
void xmpp_run(xmpp_ctx_t *ctx)
{
if (ctx->loop_status != XMPP_LOOP_NOTSTARTED) return;
if (ctx->loop_status != XMPP_LOOP_NOTSTARTED)
return;
ctx->loop_status = XMPP_LOOP_RUNNING;
while (ctx->loop_status == XMPP_LOOP_RUNNING) {

89
src/handler.c
View File

@@ -33,8 +33,7 @@
* TODO Convert handler lists to double-linked lists. Current implementation
* works for O(n).
*/
static void _handler_item_remove(xmpp_handlist_t **head,
xmpp_handlist_t *item)
static void _handler_item_remove(xmpp_handlist_t **head, xmpp_handlist_t *item)
{
xmpp_handlist_t *i = *head;
@@ -56,8 +55,7 @@ static void _handler_item_remove(xmpp_handlist_t **head,
* @param conn a Strophe connection object
* @param stanza a Strophe stanza object
*/
void handler_fire_stanza(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza)
void handler_fire_stanza(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza)
{
xmpp_handlist_t *item, *next, *head, *head_old;
const char *id, *ns, *name, *type;
@@ -75,7 +73,8 @@ void handler_fire_stanza(xmpp_conn_t * const conn,
while (item) {
/* don't fire user handlers until authentication succeeds and
and skip newly added handlers */
if ((item->user_handler && !conn->authenticated) || !item->enabled) {
if ((item->user_handler && !conn->authenticated) ||
!item->enabled) {
item = item->next;
continue;
}
@@ -127,9 +126,12 @@ void handler_fire_stanza(xmpp_conn_t * const conn,
if (!ret) {
/* handler is one-shot, so delete it */
_handler_item_remove(&conn->handlers, item);
if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
if (item->u.name) xmpp_free(conn->ctx, item->u.name);
if (item->u.type) xmpp_free(conn->ctx, item->u.type);
if (item->u.ns)
xmpp_free(conn->ctx, item->u.ns);
if (item->u.name)
xmpp_free(conn->ctx, item->u.name);
if (item->u.type)
xmpp_free(conn->ctx, item->u.type);
xmpp_free(conn->ctx, item);
}
}
@@ -171,7 +173,8 @@ uint64_t handler_fire_timed(xmpp_ctx_t * const ctx)
while (item) {
/* don't fire user handlers until authentication succeeds and
skip newly added handlers */
if ((item->user_handler && !conn->authenticated) || !item->enabled) {
if ((item->user_handler && !conn->authenticated) ||
!item->enabled) {
item = item->next;
continue;
}
@@ -236,11 +239,13 @@ static void _timed_handler_add(xmpp_conn_t * const conn,
break;
}
}
if (item) return;
if (item)
return;
/* build new item */
item = xmpp_alloc(conn->ctx, sizeof(xmpp_handlist_t));
if (!item) return;
if (!item)
return;
item->user_handler = user_handler;
item->handler = handler;
@@ -274,7 +279,8 @@ void xmpp_timed_handler_delete(xmpp_conn_t * const conn,
{
xmpp_handlist_t *item, *prev;
if (!conn->timed_handlers) return;
if (!conn->timed_handlers)
return;
prev = NULL;
item = conn->timed_handlers;
@@ -297,7 +303,8 @@ void xmpp_timed_handler_delete(xmpp_conn_t * const conn,
static void _id_handler_add(xmpp_conn_t *const conn,
xmpp_handler handler,
const char *const id,
void * const userdata, int user_handler)
void *const userdata,
int user_handler)
{
xmpp_handlist_t *item, *tail;
@@ -310,11 +317,13 @@ static void _id_handler_add(xmpp_conn_t * const conn,
}
item = item->next;
}
if (item) return;
if (item)
return;
/* build new item */
item = xmpp_alloc(conn->ctx, sizeof(xmpp_handlist_t));
if (!item) return;
if (!item)
return;
item->user_handler = user_handler;
item->handler = handler;
@@ -355,7 +364,8 @@ void xmpp_id_handler_delete(xmpp_conn_t * const conn,
prev = NULL;
item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
if (!item) return;
if (!item)
return;
while (item) {
next = item->next;
@@ -384,7 +394,8 @@ static void _handler_add(xmpp_conn_t * const conn,
const char *const ns,
const char *const name,
const char *const type,
void * const userdata, int user_handler)
void *const userdata,
int user_handler)
{
xmpp_handlist_t *item, *tail;
@@ -397,11 +408,13 @@ static void _handler_add(xmpp_conn_t * const conn,
break;
}
}
if (item) return;
if (item)
return;
/* build new item */
item = (xmpp_handlist_t *)xmpp_alloc(conn->ctx, sizeof(xmpp_handlist_t));
if (!item) return;
if (!item)
return;
item->user_handler = user_handler;
item->handler = handler;
@@ -417,20 +430,25 @@ static void _handler_add(xmpp_conn_t * const conn,
}
} else
item->u.ns = NULL;
if (name) {
item->u.name = xmpp_strdup(conn->ctx, name);
if (!item->u.name) {
if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
if (item->u.ns)
xmpp_free(conn->ctx, item->u.ns);
xmpp_free(conn->ctx, item);
return;
}
} else
item->u.name = NULL;
if (type) {
item->u.type = xmpp_strdup(conn->ctx, type);
if (!item->u.type) {
if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
if (item->u.name) xmpp_free(conn->ctx, item->u.name);
if (item->u.ns)
xmpp_free(conn->ctx, item->u.ns);
if (item->u.name)
xmpp_free(conn->ctx, item->u.name);
xmpp_free(conn->ctx, item);
}
} else
@@ -454,12 +472,12 @@ static void _handler_add(xmpp_conn_t * const conn,
*
* @ingroup Handlers
*/
void xmpp_handler_delete(xmpp_conn_t * const conn,
xmpp_handler handler)
void xmpp_handler_delete(xmpp_conn_t *const conn, xmpp_handler handler)
{
xmpp_handlist_t *prev, *item;
if (!conn->handlers) return;
if (!conn->handlers)
return;
prev = NULL;
item = conn->handlers;
@@ -470,9 +488,12 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
else
conn->handlers = item->next;
if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
if (item->u.name) xmpp_free(conn->ctx, item->u.name);
if (item->u.type) xmpp_free(conn->ctx, item->u.type);
if (item->u.ns)
xmpp_free(conn->ctx, item->u.ns);
if (item->u.name)
xmpp_free(conn->ctx, item->u.name);
if (item->u.type)
xmpp_free(conn->ctx, item->u.type);
xmpp_free(conn->ctx, item);
item = prev ? prev->next : conn->handlers;
} else {
@@ -636,9 +657,12 @@ void handler_system_delete_all(xmpp_conn_t *conn)
if (!item->user_handler) {
next = item->next;
_handler_item_remove(&conn->handlers, item);
if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
if (item->u.name) xmpp_free(conn->ctx, item->u.name);
if (item->u.type) xmpp_free(conn->ctx, item->u.type);
if (item->u.ns)
xmpp_free(conn->ctx, item->u.ns);
if (item->u.name)
xmpp_free(conn->ctx, item->u.name);
if (item->u.type)
xmpp_free(conn->ctx, item->u.type);
xmpp_free(conn->ctx, item);
item = next;
} else
@@ -686,5 +710,6 @@ void handler_system_delete_all(xmpp_conn_t *conn)
xmpp_free(conn->ctx, key2);
}
}
if (iter) hash_iter_release(iter);
if (iter)
hash_iter_release(iter);
}

23
src/hash.c
View File

@@ -46,8 +46,8 @@ struct _hash_iterator_t {
};
/** allocate and initialize a new hash table */
hash_t *hash_new(xmpp_ctx_t * const ctx, const int size,
hash_free_func free_func)
hash_t *
hash_new(xmpp_ctx_t *const ctx, const int size, hash_free_func free_func)
{
hash_t *result = NULL;
@@ -93,7 +93,8 @@ void hash_release(hash_t * const table)
while (entry != NULL) {
next = entry->next;
xmpp_free(ctx, entry->key);
if (table->free) table->free(ctx, entry->value);
if (table->free)
table->free(ctx, entry->value);
xmpp_free(ctx, entry);
entry = next;
}
@@ -114,7 +115,8 @@ static int _hash_key(hash_t *table, const char *key)
/* assume 32 bit ints */
hash ^= ((unsigned)*c++ << shift);
shift += 8;
if (shift > 24) shift = 0;
if (shift > 24)
shift = 0;
}
return hash % (unsigned)table->length;
}
@@ -153,7 +155,8 @@ int hash_add(hash_t *table, const char * const key, void *data)
if (entry == NULL) {
/* allocate and fill a new entry */
entry = xmpp_alloc(ctx, sizeof(hashentry_t));
if (!entry) return -1;
if (!entry)
return -1;
entry->key = xmpp_strdup(ctx, key);
if (!entry->key) {
xmpp_free(ctx, entry);
@@ -164,7 +167,8 @@ int hash_add(hash_t *table, const char * const key, void *data)
table->entries[table_index] = entry;
table->num_keys++;
} else {
if (table->free) table->free(ctx, entry->value);
if (table->free)
table->free(ctx, entry->value);
}
entry->value = data;
@@ -196,7 +200,8 @@ int hash_drop(hash_t *table, const char *key)
if (!strcmp(key, entry->key)) {
/* match, remove the entry */
xmpp_free(ctx, entry->key);
if (table->free) table->free(ctx, entry->value);
if (table->free)
table->free(ctx, entry->value);
if (prev == NULL) {
table->entries[table_index] = entry->next;
} else {
@@ -235,7 +240,6 @@ hash_iterator_t *hash_iter_new(hash_t *table)
return iter;
}
/** release an iterator that is no longer needed */
void hash_iter_release(hash_iterator_t *iter)
{
@@ -258,7 +262,8 @@ const char * hash_iter_next(hash_iterator_t *iter)
int i;
/* advance until we find the next entry */
if (entry != NULL) entry = entry->next;
if (entry != NULL)
entry = entry->next;
if (entry == NULL) {
/* we're off the end of list, search for a new entry */
i = iter->index + 1;

4
src/hash.h
View File

@@ -21,8 +21,8 @@ typedef struct _hash_t hash_t;
typedef void (*hash_free_func)(const xmpp_ctx_t *const ctx, void *p);
/** allocate and initialize a new hash table */
hash_t *hash_new(xmpp_ctx_t * const ctx, const int size,
hash_free_func free_func);
hash_t *
hash_new(xmpp_ctx_t *const ctx, const int size, hash_free_func free_func);
/** allocate a new reference to an existing hash table */
hash_t *hash_clone(hash_t *const table);

6
src/jid.c
View File

@@ -28,7 +28,8 @@
* @return an allocated string with the full JID or NULL if no domain
* is specified
*/
char *xmpp_jid_new(xmpp_ctx_t *ctx, const char *node,
char *xmpp_jid_new(xmpp_ctx_t *ctx,
const char *node,
const char *domain,
const char *resource)
{
@@ -36,7 +37,8 @@ char *xmpp_jid_new(xmpp_ctx_t *ctx, const char *node,
size_t len, nlen, dlen, rlen;
/* jid must at least have a domain */
if (domain == NULL) return NULL;
if (domain == NULL)
return NULL;
/* accumulate lengths */
dlen = strlen(domain);

3
src/md5.h
View File

@@ -21,7 +21,8 @@ struct MD5Context {
};
void MD5Init(struct MD5Context *context);
void MD5Update(struct MD5Context *context, unsigned char const *buf,
void MD5Update(struct MD5Context *context,
unsigned char const *buf,
uint32_t len);
void MD5Final(unsigned char digest[16], struct MD5Context *context);

1
src/parser.h
View File

@@ -27,7 +27,6 @@ typedef void (*parser_end_callback)(char *name, void * const userdata);
typedef void (*parser_stanza_callback)(xmpp_stanza_t *stanza,
void *const userdata);
parser_t *parser_new(xmpp_ctx_t *ctx,
parser_start_callback startcb,
parser_end_callback endcb,

30
src/parser_expat.c
View File

@@ -94,7 +94,8 @@ static char *_xml_name(xmpp_ctx_t *ctx, const char *nsname)
size_t len;
c = strchr(nsname, namespace_sep);
if (c == NULL) return xmpp_strdup(ctx, nsname);
if (c == NULL)
return xmpp_strdup(ctx, nsname);
c++;
len = strlen(c);
@@ -130,7 +131,8 @@ static void _set_attributes(xmpp_stanza_t *stanza, const XML_Char **attrs)
char *attr;
int i;
if (!attrs) return;
if (!attrs)
return;
for (i = 0; attrs[i]; i += 2) {
/* namespaced attributes aren't used in xmpp, discard namespace */
@@ -160,9 +162,8 @@ static void complete_inner_text(parser_t *parser)
}
}
static void _start_element(void *userdata,
const XML_Char *nsname,
const XML_Char **attrs)
static void
_start_element(void *userdata, const XML_Char *nsname, const XML_Char **attrs)
{
parser_t *parser = (parser_t *)userdata;
xmpp_stanza_t *child;
@@ -174,8 +175,7 @@ static void _start_element(void *userdata,
if (parser->depth == 0) {
/* notify the owner */
if (parser->startcb)
parser->startcb(name, (char **)attrs,
parser->userdata);
parser->startcb(name, (char **)attrs, parser->userdata);
} else {
/* build stanzas at depth 1 */
if (!parser->stanza && parser->depth != 1) {
@@ -201,8 +201,10 @@ static void _start_element(void *userdata,
}
}
if (ns) xmpp_free(parser->ctx, ns);
if (name) xmpp_free(parser->ctx, name);
if (ns)
xmpp_free(parser->ctx, ns);
if (name)
xmpp_free(parser->ctx, name);
parser->depth++;
}
@@ -224,8 +226,7 @@ static void _end_element(void *userdata, const XML_Char *name)
parser->stanza = parser->stanza->parent;
} else {
if (parser->stanzacb)
parser->stanzacb(parser->stanza,
parser->userdata);
parser->stanzacb(parser->stanza, parser->userdata);
xmpp_stanza_release(parser->stanza);
parser->stanza = NULL;
}
@@ -237,13 +238,14 @@ static void _characters(void *userdata, const XML_Char *s, int len)
parser_t *parser = (parser_t *)userdata;
char *p;
if (parser->depth < 2) return;
if (parser->depth < 2)
return;
/* Join all parts to a single resulting string. Stanza is created in
* _start_element() and _end_element(). */
if (parser->inner_text_used + len >= parser->inner_text_size) {
parser->inner_text_size = parser->inner_text_used + len + 1 +
INNER_TEXT_PADDING;
parser->inner_text_size =
parser->inner_text_used + len + 1 + INNER_TEXT_PADDING;
p = xmpp_realloc(parser->ctx, parser->inner_text,
parser->inner_text_size);
if (p == NULL) {

54
src/parser_libxml2.c
View File

@@ -36,13 +36,14 @@ struct _parser_t {
xmpp_stanza_t *stanza;
};
static void _set_attributes(xmpp_stanza_t *stanza, int nattrs,
const xmlChar **attrs)
static void
_set_attributes(xmpp_stanza_t *stanza, int nattrs, const xmlChar **attrs)
{
int i, len;
char *value;
if (!attrs) return;
if (!attrs)
return;
/* SAX2 uses array of localname/prefix/uri/value_begin/value_end */
for (i = 0; i < nattrs * 5; i += 5) {
@@ -59,17 +60,19 @@ static void _set_attributes(xmpp_stanza_t *stanza, int nattrs,
/* SAX2 gives us the attrs in an incredibly inconvenient array,
* convert it to what the start callback is expecting */
static char **_convert_attrs(parser_t *parser, int nattrs,
const xmlChar **attrs)
static char **
_convert_attrs(parser_t *parser, int nattrs, const xmlChar **attrs)
{
int c, i, o, len;
char *value;
char **ret;
if (!attrs) return NULL;
if (!attrs)
return NULL;
ret = xmpp_alloc(parser->ctx, (nattrs + 1) * 2 * sizeof(char *));
if (!ret) return NULL;
if (!ret)
return NULL;
memset(ret, 0, (nattrs + 1) * 2 * sizeof(char *));
for (c = 0; c < nattrs; c++) {
@@ -97,18 +100,24 @@ static void _free_cbattrs(parser_t *parser, char **attrs)
return;
for (i = 0; attrs[i]; i += 2) {
if (attrs[i]) xmpp_free(parser->ctx, attrs[i]);
if (attrs[i+1]) xmpp_free(parser->ctx, attrs[i+1]);
if (attrs[i])
xmpp_free(parser->ctx, attrs[i]);
if (attrs[i + 1])
xmpp_free(parser->ctx, attrs[i + 1]);
}
xmpp_free(parser->ctx, attrs);
}
static void _start_element(void *userdata,
const xmlChar *name, const xmlChar *prefix,
const xmlChar *uri, int nnamespaces,
const xmlChar **namespaces, int nattrs,
int ndefaulted, const xmlChar **attrs)
const xmlChar *name,
const xmlChar *prefix,
const xmlChar *uri,
int nnamespaces,
const xmlChar **namespaces,
int nattrs,
int ndefaulted,
const xmlChar **attrs)
{
parser_t *parser = (parser_t *)userdata;
xmpp_stanza_t *child;
@@ -118,8 +127,7 @@ static void _start_element(void *userdata,
/* notify the owner */
if (parser->startcb) {
cbattrs = _convert_attrs(parser, nattrs, attrs);
parser->startcb((char *)name, cbattrs,
parser->userdata);
parser->startcb((char *)name, cbattrs, parser->userdata);
_free_cbattrs(parser, cbattrs);
}
} else {
@@ -163,8 +171,10 @@ static void _start_element(void *userdata,
parser->depth++;
}
static void _end_element(void *userdata, const xmlChar *name,
const xmlChar *prefix, const xmlChar *uri)
static void _end_element(void *userdata,
const xmlChar *name,
const xmlChar *prefix,
const xmlChar *uri)
{
parser_t *parser = (parser_t *)userdata;
@@ -180,8 +190,7 @@ static void _end_element(void *userdata, const xmlChar *name,
parser->stanza = parser->stanza->parent;
} else {
if (parser->stanzacb)
parser->stanzacb(parser->stanza,
parser->userdata);
parser->stanzacb(parser->stanza, parser->userdata);
xmpp_stanza_release(parser->stanza);
parser->stanza = NULL;
}
@@ -194,7 +203,8 @@ static void _characters(void *userdata, const xmlChar *chr, int len)
xmpp_stanza_t *stanza;
/* skip unimportant whitespace, etc */
if (parser->depth < 2) return;
if (parser->depth < 2)
return;
/* create and populate stanza */
stanza = xmpp_stanza_new(parser->ctx);
@@ -265,8 +275,8 @@ int parser_reset(parser_t *parser)
parser->stanza = NULL;
parser->depth = 0;
parser->xmlctx = xmlCreatePushParserCtxt(&parser->handlers,
parser, NULL, 0, NULL);
parser->xmlctx =
xmlCreatePushParserCtxt(&parser->handlers, parser, NULL, 0, NULL);
return parser->xmlctx ? 1 : 0;
}

20
src/rand.c
View File

@@ -62,8 +62,8 @@ struct _xmpp_rand_t {
/* adds two arrays as numbers in big-endian representation and stores
* result in the first one.
*/
static void arr_add(uint8_t *arr1, size_t arr1_len,
uint8_t *arr2, size_t arr2_len)
static void
arr_add(uint8_t *arr1, size_t arr1_len, uint8_t *arr2, size_t arr2_len)
{
size_t i;
uint32_t acc;
@@ -89,8 +89,10 @@ static void store_be32(uint32_t val, uint8_t be[4])
be[3] = (uint8_t)(val & 0xff);
}
static void Hash_df(uint8_t *input_string, size_t input_string_len,
uint8_t *output_string, size_t no_of_bytes_to_return)
static void Hash_df(uint8_t *input_string,
size_t input_string_len,
uint8_t *output_string,
size_t no_of_bytes_to_return)
{
uint8_t counter;
uint8_t temp[round_up(seedlen, outlen)];
@@ -119,7 +121,8 @@ static void Hash_df(uint8_t *input_string, size_t input_string_len,
static void Hash_DRBG_Instantiate(Hash_DRBG_CTX *ctx,
uint8_t *entropy_input,
size_t entropy_input_len,
uint8_t *nonce, size_t nonce_len)
uint8_t *nonce,
size_t nonce_len)
{
uint8_t seed_material[ENTROPY_MAX + NONCE_MAX];
uint8_t seed0[seedlen + 1];
@@ -162,8 +165,8 @@ static void Hash_DRBG_Reseed(Hash_DRBG_CTX *ctx,
ctx->reseed_counter = 1;
}
static void Hashgen(uint8_t *V, uint8_t *output,
size_t requested_number_of_bytes)
static void
Hashgen(uint8_t *V, uint8_t *output, size_t requested_number_of_bytes)
{
uint8_t data[seedlen];
uint8_t W[GENERATE_MAX];
@@ -187,7 +190,8 @@ static void Hashgen(uint8_t *V, uint8_t *output,
}
/* assume additional_input is zero length string */
static int Hash_DRBG_Generate(Hash_DRBG_CTX *ctx, uint8_t *output,
static int Hash_DRBG_Generate(Hash_DRBG_CTX *ctx,
uint8_t *output,
size_t requested_number_of_bytes)
{
uint8_t H[outlen];

323
src/resolver.c
View File

@@ -52,7 +52,8 @@ static int resolver_ares_srv_lookup_buf(xmpp_ctx_t *ctx,
const unsigned char *buf,
size_t len,
resolver_srv_rr_t **srv_rr_list);
static int resolver_ares_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
static int resolver_ares_srv_lookup(xmpp_ctx_t *ctx,
const char *fulldomain,
resolver_srv_rr_t **srv_rr_list);
#endif /* HAVE_CARES */
@@ -64,10 +65,12 @@ static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
#endif /* !HAVE_CARES */
#ifdef _WIN32
static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx,
const char *fulldomain,
resolver_srv_rr_t **srv_rr_list);
static int resolver_win32_srv_query(const char *fulldomain,
unsigned char *buf, size_t len);
unsigned char *buf,
size_t len);
#endif /* _WIN32 */
/*******************************************************************************
@@ -118,8 +121,7 @@ static void resolver_srv_list_sort(resolver_srv_rr_t **srv_rr_list)
*/
if ((rr_current->priority > rr_next->priority) ||
(rr_current->priority == rr_next->priority &&
rr_current->weight < rr_next->weight))
{
rr_current->weight < rr_next->weight)) {
/* Swap node */
swap = 1;
if (rr_prev != NULL) {
@@ -145,8 +147,10 @@ static void resolver_srv_list_sort(resolver_srv_rr_t **srv_rr_list)
*srv_rr_list = rr_head;
}
int resolver_srv_lookup_buf(xmpp_ctx_t *ctx, const unsigned char *buf,
size_t len, resolver_srv_rr_t **srv_rr_list)
int resolver_srv_lookup_buf(xmpp_ctx_t *ctx,
const unsigned char *buf,
size_t len,
resolver_srv_rr_t **srv_rr_list)
{
int set;
@@ -160,8 +164,11 @@ int resolver_srv_lookup_buf(xmpp_ctx_t *ctx, const unsigned char *buf,
return set;
}
int resolver_srv_lookup(xmpp_ctx_t *ctx, const char *service, const char *proto,
const char *domain, resolver_srv_rr_t **srv_rr_list)
int resolver_srv_lookup(xmpp_ctx_t *ctx,
const char *service,
const char *proto,
const char *domain,
resolver_srv_rr_t **srv_rr_list)
{
#define RESOLVER_BUF_MAX 65536
unsigned char *buf;
@@ -172,8 +179,8 @@ int resolver_srv_lookup(xmpp_ctx_t *ctx, const char *service, const char *proto,
(void)buf;
(void)len;
xmpp_snprintf(fulldomain, sizeof(fulldomain),
"_%s._%s.%s", service, proto, domain);
xmpp_snprintf(fulldomain, sizeof(fulldomain), "_%s._%s.%s", service, proto,
domain);
*srv_rr_list = NULL;
@@ -259,9 +266,11 @@ static uint8_t message_header_rcode(const struct message_header *header)
* Returns length of the non-truncated resulting string, may be bigger than
* name_max.
*/
static size_t message_name_append_safe(char *name, size_t name_len,
static size_t message_name_append_safe(char *name,
size_t name_len,
size_t name_max,
const char *tail, size_t tail_len)
const char *tail,
size_t tail_len)
{
size_t copy_len;
@@ -274,9 +283,11 @@ static size_t message_name_append_safe(char *name, size_t name_len,
}
/* Returns length of the compressed name. This is NOT the same as strlen(). */
static unsigned message_name_get(const unsigned char *buf, size_t buf_len,
static unsigned message_name_get(const unsigned char *buf,
size_t buf_len,
unsigned buf_offset,
char *name, size_t name_max)
char *name,
size_t name_max)
{
size_t name_len = 0;
unsigned i = buf_offset;
@@ -284,26 +295,29 @@ static unsigned message_name_get(const unsigned char *buf, size_t buf_len,
unsigned rc;
unsigned char label_len;
while (1) {
if (i >= buf_len) return 0;
if (i >= buf_len)
return 0;
label_len = buf[i++];
if (label_len == 0) break;
if (label_len == 0)
break;
/* Label */
if ((label_len & 0xc0) == 0) {
if (i + label_len - 1 >= buf_len) return 0;
if (i + label_len - 1 >= buf_len)
return 0;
if (name != NULL) {
name_len = message_name_append_safe(name, name_len, name_max,
(char *)&buf[i], label_len);
name_len = message_name_append_safe(name, name_len, name_max,
".", 1);
name_len =
message_name_append_safe(name, name_len, name_max, ".", 1);
}
i += label_len;
/* Pointer */
} else if ((label_len & 0xc0) == 0xc0) {
if (i >= buf_len) return 0;
if (i >= buf_len)
return 0;
pointer = (label_len & 0x3f) << 8 | buf[i++];
if (name != NULL && name_len >= name_max && name_max > 0) {
/* We have filled the name buffer. Don't pass it recursively. */
@@ -311,10 +325,11 @@ static unsigned message_name_get(const unsigned char *buf, size_t buf_len,
name = NULL;
name_max = 0;
}
rc = message_name_get(buf, buf_len, pointer,
name != NULL ? &name[name_len] : NULL,
rc = message_name_get(
buf, buf_len, pointer, name != NULL ? &name[name_len] : NULL,
name_max > name_len ? name_max - name_len : 0);
if (rc == 0) return 0;
if (rc == 0)
return 0;
/* Pointer is always the last. */
break;
@@ -324,7 +339,8 @@ static unsigned message_name_get(const unsigned char *buf, size_t buf_len,
}
}
if (label_len == 0) {
if (name_len == 0) name_len = 1;
if (name_len == 0)
name_len = 1;
/*
* At this point name_len is length of the resulting name,
* including '\0'. This value can be exported to allocate buffer
@@ -342,13 +358,14 @@ static unsigned message_name_get(const unsigned char *buf, size_t buf_len,
return i - buf_offset;
}
static unsigned message_name_len(const unsigned char *buf, size_t buf_len,
unsigned buf_offset)
static unsigned
message_name_len(const unsigned char *buf, size_t buf_len, unsigned buf_offset)
{
return message_name_get(buf, buf_len, buf_offset, NULL, SIZE_MAX);
}
#define BUF_OVERFLOW_CHECK(ptr, len) do { \
#define BUF_OVERFLOW_CHECK(ptr, len) \
do { \
if ((ptr) >= (len)) { \
if (*srv_rr_list != NULL) \
resolver_srv_free(ctx, *srv_rr_list); \
@@ -384,8 +401,7 @@ static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
header.nscount = xmpp_ntohs_ptr(&buf[8]);
header.arcount = xmpp_ntohs_ptr(&buf[10]);
if (message_header_qr(&header) != MESSAGE_RESPONSE ||
message_header_rcode(&header) != 0)
{
message_header_rcode(&header) != 0) {
return XMPP_DOMAIN_NOT_FOUND;
}
j = MESSAGE_HEADER_LEN;
@@ -395,7 +411,8 @@ static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
BUF_OVERFLOW_CHECK(j, len);
name_len = message_name_len(buf, len, j);
/* error in name format */
if (name_len == 0) return XMPP_DOMAIN_NOT_FOUND;
if (name_len == 0)
return XMPP_DOMAIN_NOT_FOUND;
j += name_len + 4;
}
@@ -403,7 +420,8 @@ static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
BUF_OVERFLOW_CHECK(j, len);
name_len = message_name_len(buf, len, j);
/* error in name format */
if (name_len == 0) return XMPP_DOMAIN_NOT_FOUND;
if (name_len == 0)
return XMPP_DOMAIN_NOT_FOUND;
j += name_len;
BUF_OVERFLOW_CHECK(j + 16, len);
type = xmpp_ntohs_ptr(&buf[j]);
@@ -477,8 +495,8 @@ static int resolver_ares_srv_lookup_buf(xmpp_ctx_t *ctx,
return *srv_rr_list == NULL ? XMPP_DOMAIN_NOT_FOUND : XMPP_DOMAIN_FOUND;
}
static void ares_srv_lookup_callback(void *arg, int status, int timeouts,
unsigned char *buf, int len)
static void ares_srv_lookup_callback(
void *arg, int status, int timeouts, unsigned char *buf, int len)
{
struct resolver_ares_ctx *actx = arg;
@@ -489,7 +507,8 @@ static void ares_srv_lookup_callback(void *arg, int status, int timeouts,
&actx->srv_rr_list);
}
static int resolver_ares_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
static int resolver_ares_srv_lookup(xmpp_ctx_t *ctx,
const char *fulldomain,
resolver_srv_rr_t **srv_rr_list)
{
struct resolver_ares_ctx actx;
@@ -546,8 +565,7 @@ static int resolver_ares_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
#include <windns.h>
#include <Iphlpapi.h>
struct dnsquery_header
{
struct dnsquery_header {
unsigned short id;
unsigned char qr;
unsigned char opcode;
@@ -563,14 +581,16 @@ struct dnsquery_header
unsigned short arcount;
};
struct dnsquery_question
{
struct dnsquery_question {
char qname[1024];
unsigned short qtype;
unsigned short qclass;
};
static void netbuf_add_16bitnum(unsigned char *buf, int buflen, int *offset, unsigned short num)
static void netbuf_add_16bitnum(unsigned char *buf,
int buflen,
int *offset,
unsigned short num)
{
unsigned char *start = buf + *offset;
unsigned char *p = start;
@@ -582,8 +602,8 @@ static void netbuf_add_16bitnum(unsigned char *buf, int buflen, int *offset, uns
*offset += 2;
}
static void netbuf_add_domain_name(unsigned char *buf, int buflen, int *offset,
char *name)
static void
netbuf_add_domain_name(unsigned char *buf, int buflen, int *offset, char *name)
{
unsigned char *start = buf + *offset;
unsigned char *p = start;
@@ -591,31 +611,26 @@ static void netbuf_add_domain_name(unsigned char *buf, int buflen, int *offset,
wordstart = (unsigned char *)name;
while (*wordstart)
{
while (*wordstart) {
int len;
wordend = wordstart;
while (*wordend && *wordend != '.')
{
while (*wordend && *wordend != '.') {
wordend++;
}
len = (int)(wordend - wordstart);
if (len > 0x3F)
{
if (len > 0x3F) {
len = 0x3F;
}
*p++ = len;
while (wordstart != wordend)
{
while (wordstart != wordend) {
*p++ = *wordstart++;
}
if (*wordstart == '.')
{
if (*wordstart == '.') {
wordstart++;
}
}
@@ -625,21 +640,21 @@ static void netbuf_add_domain_name(unsigned char *buf, int buflen, int *offset,
*offset += (int)(p - start);
}
static void netbuf_add_dnsquery_header(unsigned char *buf, int buflen, int *offset, struct dnsquery_header *header)
static void netbuf_add_dnsquery_header(unsigned char *buf,
int buflen,
int *offset,
struct dnsquery_header *header)
{
unsigned char *p;
netbuf_add_16bitnum(buf, buflen, offset, header->id);
p = buf + *offset;
*p++ = ((header->qr & 0x01) << 7)
| ((header->opcode & 0x0F) << 3)
| ((header->aa & 0x01) << 2)
| ((header->tc & 0x01) << 1)
| ((header->rd & 0x01));
*p++ = ((header->ra & 0x01) << 7)
| ((header->z & 0x07) << 4)
| ((header->rcode & 0x0F));
*p++ = ((header->qr & 0x01) << 7) | ((header->opcode & 0x0F) << 3) |
((header->aa & 0x01) << 2) | ((header->tc & 0x01) << 1) |
((header->rd & 0x01));
*p++ = ((header->ra & 0x01) << 7) | ((header->z & 0x07) << 4) |
((header->rcode & 0x0F));
*offset += 2;
netbuf_add_16bitnum(buf, buflen, offset, header->qdcount);
@@ -648,31 +663,38 @@ static void netbuf_add_dnsquery_header(unsigned char *buf, int buflen, int *offs
netbuf_add_16bitnum(buf, buflen, offset, header->arcount);
}
static void netbuf_add_dnsquery_question(unsigned char *buf, int buflen, int *offset, struct dnsquery_question *question)
static void netbuf_add_dnsquery_question(unsigned char *buf,
int buflen,
int *offset,
struct dnsquery_question *question)
{
netbuf_add_domain_name(buf, buflen, offset, question->qname);
netbuf_add_16bitnum(buf, buflen, offset, question->qtype);
netbuf_add_16bitnum(buf, buflen, offset, question->qclass);
}
static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx,
const char *fulldomain,
resolver_srv_rr_t **srv_rr_list)
{
resolver_srv_rr_t *rr;
HINSTANCE hdnsapi = NULL;
DNS_STATUS (WINAPI * pDnsQuery_A)(PCSTR, WORD, DWORD, PIP4_ARRAY, DNS_RECORDA**, PVOID*);
DNS_STATUS(WINAPI * pDnsQuery_A)
(PCSTR, WORD, DWORD, PIP4_ARRAY, DNS_RECORDA **, PVOID *);
void(WINAPI * pDnsRecordListFree)(DNS_RECORDA *, DNS_FREE_TYPE);
if (hdnsapi = LoadLibrary("dnsapi.dll")) {
pDnsQuery_A = (void *)GetProcAddress(hdnsapi, "DnsQuery_A");
pDnsRecordListFree = (void *)GetProcAddress(hdnsapi, "DnsRecordListFree");
pDnsRecordListFree =
(void *)GetProcAddress(hdnsapi, "DnsRecordListFree");
if (pDnsQuery_A && pDnsRecordListFree) {
DNS_RECORDA *dnsrecords = NULL;
DNS_STATUS error;
error = pDnsQuery_A(fulldomain, DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, &dnsrecords, NULL);
error = pDnsQuery_A(fulldomain, DNS_TYPE_SRV, DNS_QUERY_STANDARD,
NULL, &dnsrecords, NULL);
if (error == 0) {
DNS_RECORDA *current = dnsrecords;
@@ -704,15 +726,15 @@ static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
return *srv_rr_list != NULL ? XMPP_DOMAIN_FOUND : XMPP_DOMAIN_NOT_FOUND;
}
static int resolver_win32_srv_query(const char *fulldomain,
unsigned char *buf, size_t len)
static int
resolver_win32_srv_query(const char *fulldomain, unsigned char *buf, size_t len)
{
int set = 0;
int insize = 0;
/* if dnsapi didn't work/isn't there, try querying the dns server manually */
if (!set)
{
/* if dnsapi didn't work/isn't there, try querying the dns server manually
*/
if (!set) {
struct dnsquery_header header;
struct dnsquery_question question;
int offset = 0;
@@ -723,18 +745,17 @@ static int resolver_win32_srv_query(const char *fulldomain,
int numdnsservers = 0;
int j;
/* Try getting the DNS server ips from GetNetworkParams() in iphlpapi first */
if (!numdnsservers)
{
/* Try getting the DNS server ips from GetNetworkParams() in iphlpapi
* first */
if (!numdnsservers) {
HINSTANCE hiphlpapi = NULL;
DWORD(WINAPI * pGetNetworkParams)(PFIXED_INFO, PULONG);
if (hiphlpapi = LoadLibrary("Iphlpapi.dll"))
{
pGetNetworkParams = (void *)GetProcAddress(hiphlpapi, "GetNetworkParams");
if (hiphlpapi = LoadLibrary("Iphlpapi.dll")) {
pGetNetworkParams =
(void *)GetProcAddress(hiphlpapi, "GetNetworkParams");
if (pGetNetworkParams)
{
if (pGetNetworkParams) {
FIXED_INFO *fi;
ULONG len;
DWORD error;
@@ -743,13 +764,13 @@ static int resolver_win32_srv_query(const char *fulldomain,
len = 65535;
fi = (FIXED_INFO *)buffer;
if ((error = pGetNetworkParams(fi, &len)) == ERROR_SUCCESS)
{
if ((error = pGetNetworkParams(fi, &len)) ==
ERROR_SUCCESS) {
IP_ADDR_STRING *pias = &(fi->DnsServerList);
while (pias && numdnsservers < 16)
{
strcpy(dnsserverips[numdnsservers++], pias->IpAddress.String);
while (pias && numdnsservers < 16) {
strcpy(dnsserverips[numdnsservers++],
pias->IpAddress.String);
pias = pias->Next;
}
}
@@ -759,48 +780,49 @@ static int resolver_win32_srv_query(const char *fulldomain,
}
/* Next, try getting the DNS server ips from the registry */
if (!numdnsservers)
{
if (!numdnsservers) {
HKEY search;
LONG error;
error = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters", 0, KEY_READ, &search);
error = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters", 0,
KEY_READ, &search);
if (error != ERROR_SUCCESS)
{
error = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &search);
if (error != ERROR_SUCCESS) {
error = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0,
KEY_READ, &search);
}
if (error == ERROR_SUCCESS)
{
if (error == ERROR_SUCCESS) {
char name[512];
DWORD len = 512;
error = RegQueryValueEx(search, "NameServer", NULL, NULL, (LPBYTE)name, &len);
error = RegQueryValueEx(search, "NameServer", NULL, NULL,
(LPBYTE)name, &len);
if (error != ERROR_SUCCESS)
{
error = RegQueryValueEx(search, "DhcpNameServer", NULL, NULL, (LPBYTE)name, &len);
if (error != ERROR_SUCCESS) {
error = RegQueryValueEx(search, "DhcpNameServer", NULL,
NULL, (LPBYTE)name, &len);
}
if (error == ERROR_SUCCESS)
{
if (error == ERROR_SUCCESS) {
char *parse = "0123456789.", *start, *end;
start = name;
end = name;
name[len] = '\0';
while (*start && numdnsservers < 16)
{
while (strchr(parse, *end))
{
while (*start && numdnsservers < 16) {
while (strchr(parse, *end)) {
end++;
}
strncpy(dnsserverips[numdnsservers++], start, end - start);
strncpy(dnsserverips[numdnsservers++], start,
end - start);
while (*end && !strchr(parse, *end))
{
while (*end && !strchr(parse, *end)) {
end++;
}
@@ -812,72 +834,71 @@ static int resolver_win32_srv_query(const char *fulldomain,
RegCloseKey(search);
}
if (!numdnsservers)
{
if (!numdnsservers) {
HKEY searchlist;
LONG error;
error = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces", 0, KEY_READ, &searchlist);
error = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\P"
"arameters\\Interfaces",
0, KEY_READ, &searchlist);
if (error == ERROR_SUCCESS)
{
if (error == ERROR_SUCCESS) {
unsigned int i;
DWORD numinterfaces = 0;
RegQueryInfoKey(searchlist, NULL, NULL, NULL, &numinterfaces, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
RegQueryInfoKey(searchlist, NULL, NULL, NULL, &numinterfaces,
NULL, NULL, NULL, NULL, NULL, NULL, NULL);
for (i = 0; i < numinterfaces; i++)
{
for (i = 0; i < numinterfaces; i++) {
char name[512];
DWORD len = 512;
HKEY searchentry;
RegEnumKeyEx(searchlist, i, (LPTSTR)name, &len, NULL, NULL, NULL, NULL);
RegEnumKeyEx(searchlist, i, (LPTSTR)name, &len, NULL, NULL,
NULL, NULL);
if (RegOpenKeyEx(searchlist, name, 0, KEY_READ, &searchentry) == ERROR_SUCCESS)
{
if (RegQueryValueEx(searchentry, "DhcpNameServer", NULL, NULL, (LPBYTE)name, &len) == ERROR_SUCCESS)
{
if (RegOpenKeyEx(searchlist, name, 0, KEY_READ,
&searchentry) == ERROR_SUCCESS) {
if (RegQueryValueEx(searchentry, "DhcpNameServer", NULL,
NULL, (LPBYTE)name,
&len) == ERROR_SUCCESS) {
char *parse = "0123456789.", *start, *end;
start = name;
end = name;
name[len] = '\0';
while (*start && numdnsservers < 16)
{
while (strchr(parse, *end))
{
while (*start && numdnsservers < 16) {
while (strchr(parse, *end)) {
end++;
}
strncpy(dnsserverips[numdnsservers++], start, end - start);
strncpy(dnsserverips[numdnsservers++], start,
end - start);
while (*end && !strchr(parse, *end))
{
while (*end && !strchr(parse, *end)) {
end++;
}
start = end;
}
}
else if (RegQueryValueEx(searchentry, "NameServer", NULL, NULL, (LPBYTE)name, &len) == ERROR_SUCCESS)
{
} else if (RegQueryValueEx(searchentry, "NameServer",
NULL, NULL, (LPBYTE)name,
&len) == ERROR_SUCCESS) {
char *parse = "0123456789.", *start, *end;
start = name;
end = name;
name[len] = '\0';
while (*start && numdnsservers < 16)
{
while (strchr(parse, *end))
{
while (*start && numdnsservers < 16) {
while (strchr(parse, *end)) {
end++;
}
strncpy(dnsserverips[numdnsservers++], start, end - start);
strncpy(dnsserverips[numdnsservers++], start,
end - start);
while (*end && !strchr(parse, *end))
{
while (*end && !strchr(parse, *end)) {
end++;
}
@@ -892,8 +913,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
}
/* If we have a DNS server, use it */
if (numdnsservers)
{
if (numdnsservers) {
ULONG nonblocking = 1;
int i;
@@ -912,8 +932,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
netbuf_add_dnsquery_question(buf, (int)len, &offset, &question);
insize = 0;
for (i = 0; i < numdnsservers && insize <= 0; i++)
{
for (i = 0; i < numdnsservers && insize <= 0; i++) {
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
ioctlsocket(sock, FIONBIO, &nonblocking);
@@ -924,23 +943,18 @@ static int resolver_win32_srv_query(const char *fulldomain,
dnsaddr.sin_addr.s_addr = inet_addr(dnsserverips[i]);
addrlen = sizeof(dnsaddr);
sendto(sock, (char *)buf, offset, 0, (struct sockaddr *)&dnsaddr, addrlen);
for (j = 0; j < 50; j++)
{
insize = recvfrom(sock, (char *)buf, (int)len, 0, (struct sockaddr *)&dnsaddr, &addrlen);
if (insize == SOCKET_ERROR)
{
if (sock_error() == WSAEWOULDBLOCK)
{
sendto(sock, (char *)buf, offset, 0,
(struct sockaddr *)&dnsaddr, addrlen);
for (j = 0; j < 50; j++) {
insize = recvfrom(sock, (char *)buf, (int)len, 0,
(struct sockaddr *)&dnsaddr, &addrlen);
if (insize == SOCKET_ERROR) {
if (sock_error() == WSAEWOULDBLOCK) {
Sleep(100);
}
else
{
} else {
break;
}
}
else
{
} else {
break;
}
}
@@ -949,7 +963,6 @@ static int resolver_win32_srv_query(const char *fulldomain,
}
set = insize > 0;
}
}
return set ? insize : -1;

13
src/resolver.h
View File

@@ -46,8 +46,10 @@ void resolver_shutdown(void);
*
* @return XMPP_DOMAIN_FOUND on success or XMPP_DOMAIN_NOT_FOUND on fail
*/
int resolver_srv_lookup_buf(xmpp_ctx_t *ctx, const unsigned char *buf,
size_t len, resolver_srv_rr_t **srv_rr_list);
int resolver_srv_lookup_buf(xmpp_ctx_t *ctx,
const unsigned char *buf,
size_t len,
resolver_srv_rr_t **srv_rr_list);
/** Resolve SRV record.
*
* @param ctx a Strophe context object
@@ -58,8 +60,11 @@ int resolver_srv_lookup_buf(xmpp_ctx_t *ctx, const unsigned char *buf,
*
* @return XMPP_DOMAIN_FOUND on success or XMPP_DOMAIN_NOT_FOUND on fail
*/
int resolver_srv_lookup(xmpp_ctx_t *ctx, const char *service, const char *proto,
const char *domain, resolver_srv_rr_t **srv_rr_list);
int resolver_srv_lookup(xmpp_ctx_t *ctx,
const char *service,
const char *proto,
const char *domain,
resolver_srv_rr_t **srv_rr_list);
/** Release a list returned by resolver_srv_lookup() or
* resolver_srv_lookup_buf().

63
src/sasl.c
View File

@@ -36,9 +36,9 @@
#endif
#endif /* _MSC_VER */
/** generate authentication string for the SASL PLAIN mechanism */
char *sasl_plain(xmpp_ctx_t *ctx, const char *authid, const char *password) {
char *sasl_plain(xmpp_ctx_t *ctx, const char *authid, const char *password)
{
size_t idlen, passlen;
size_t msglen;
char *result = NULL;
@@ -113,13 +113,17 @@ static hash_t *_parse_digest_challenge(xmpp_ctx_t *ctx, const char *msg)
s = text;
while (*s != '\0') {
/* skip any leading commas and spaces */
while ((*s == ',') || (*s == ' ')) s++;
while ((*s == ',') || (*s == ' '))
s++;
/* accumulate a key ending at '=' */
t = s;
while ((*t != '=') && (*t != '\0')) t++;
if (*t == '\0') break; /* bad string */
while ((*t != '=') && (*t != '\0'))
t++;
if (*t == '\0')
break; /* bad string */
key = _make_string(ctx, (char *)s, (t - s));
if (key == NULL) break;
if (key == NULL)
break;
/* advance our start pointer past the key */
s = t + 1;
t = s;
@@ -136,7 +140,8 @@ static hash_t *_parse_digest_challenge(xmpp_ctx_t *ctx, const char *msg)
}
/* otherwise, accumulate a value ending in ',' or '\0' */
} else {
while ((*t != ',') && (*t != '\0')) t++;
while ((*t != ',') && (*t != '\0'))
t++;
value = _make_string(ctx, (char *)s, (t - s));
s = t;
}
@@ -168,8 +173,12 @@ static void _digest_to_hex(const char *digest, char *hex)
}
/** append 'key="value"' to a buffer, growing as necessary */
static char *_add_key(xmpp_ctx_t *ctx, hash_t *table, const char *key,
char *buf, int *len, int quote)
static char *_add_key(xmpp_ctx_t *ctx,
hash_t *table,
const char *key,
char *buf,
int *len,
int quote)
{
int olen, nlen;
int keylen, valuelen;
@@ -181,7 +190,8 @@ static char *_add_key(xmpp_ctx_t *ctx, hash_t *table, const char *key,
buf = xmpp_alloc(ctx, 1);
buf[0] = '\0';
}
if (buf == NULL) return NULL;
if (buf == NULL)
return NULL;
/* get current string length */
olen = strlen(buf);
@@ -204,21 +214,28 @@ static char *_add_key(xmpp_ctx_t *ctx, hash_t *table, const char *key,
if (buf != NULL) {
c = buf + olen;
if (olen) *c++ = ',';
memcpy(c, key, keylen); c += keylen;
if (olen)
*c++ = ',';
memcpy(c, key, keylen);
c += keylen;
*c++ = '=';
memcpy(c, qvalue, valuelen); c += valuelen;
memcpy(c, qvalue, valuelen);
c += valuelen;
*c++ = '\0';
}
if (quote) xmpp_free(ctx, (char *)qvalue);
if (quote)
xmpp_free(ctx, (char *)qvalue);
return buf;
}
/** generate auth response string for the SASL DIGEST-MD5 mechanism */
char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
const char *jid, const char *password) {
char *sasl_digest_md5(xmpp_ctx_t *ctx,
const char *challenge,
const char *jid,
const char *password)
{
hash_t *table;
char *result = NULL;
char *node, *domain, *realm;
@@ -363,8 +380,10 @@ char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
}
/** generate auth response string for the SASL SCRAM-SHA-1 mechanism */
char *sasl_scram_sha1(xmpp_ctx_t *ctx, const char *challenge,
const char *first_bare, const char *jid,
char *sasl_scram_sha1(xmpp_ctx_t *ctx,
const char *challenge,
const char *first_bare,
const char *jid,
const char *password)
{
uint8_t key[SHA1_DIGEST_SIZE];
@@ -430,8 +449,8 @@ char *sasl_scram_sha1(xmpp_ctx_t *ctx, const char *challenge,
xmpp_snprintf(auth, auth_len, "%s,%s,%s", first_bare + 3, challenge,
response);
SCRAM_SHA1_ClientKey((uint8_t *)password, strlen(password),
(uint8_t *)sval, sval_len, (uint32_t)ival, key);
SCRAM_SHA1_ClientKey((uint8_t *)password, strlen(password), (uint8_t *)sval,
sval_len, (uint32_t)ival, key);
SCRAM_SHA1_ClientSignature(key, (uint8_t *)auth, strlen(auth), sign);
for (j = 0; j < SHA1_DIGEST_SIZE; j++) {
sign[j] ^= key[j];
@@ -450,8 +469,8 @@ char *sasl_scram_sha1(xmpp_ctx_t *ctx, const char *challenge,
strcat(response, sign_b64);
xmpp_free(ctx, sign_b64);
response_b64 = xmpp_base64_encode(ctx, (unsigned char *)response,
strlen(response));
response_b64 =
xmpp_base64_encode(ctx, (unsigned char *)response, strlen(response));
if (!response_b64) {
goto out_response;
}

12
src/sasl.h
View File

@@ -21,10 +21,14 @@
/** low-level sasl routines */
char *sasl_plain(xmpp_ctx_t *ctx, const char *authid, const char *password);
char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
const char *jid, const char *password);
char *sasl_scram_sha1(xmpp_ctx_t *ctx, const char *challenge,
const char *first_bare, const char *jid,
char *sasl_digest_md5(xmpp_ctx_t *ctx,
const char *challenge,
const char *jid,
const char *password);
char *sasl_scram_sha1(xmpp_ctx_t *ctx,
const char *challenge,
const char *first_bare,
const char *jid,
const char *password);
#endif /* _LIBXMPP_SASL_H__ */

23
src/scram.c
View File

@@ -29,8 +29,10 @@
static const uint8_t ipad = 0x36;
static const uint8_t opad = 0x5C;
static void crypto_HMAC_SHA1(const uint8_t *key, size_t key_len,
const uint8_t *text, size_t len,
static void crypto_HMAC_SHA1(const uint8_t *key,
size_t key_len,
const uint8_t *text,
size_t len,
uint8_t *digest)
{
uint8_t key_pad[HMAC_BLOCK_SIZE];
@@ -64,8 +66,11 @@ static void crypto_HMAC_SHA1(const uint8_t *key, size_t key_len,
crypto_SHA1_Final(&ctx, digest);
}
static void SCRAM_SHA1_Hi(const uint8_t *text, size_t len,
const uint8_t *salt, size_t salt_len, uint32_t i,
static void SCRAM_SHA1_Hi(const uint8_t *text,
size_t len,
const uint8_t *salt,
size_t salt_len,
uint32_t i,
uint8_t *digest)
{
int k;
@@ -97,8 +102,11 @@ static void SCRAM_SHA1_Hi(const uint8_t *text, size_t len,
}
}
void SCRAM_SHA1_ClientKey(const uint8_t *password, size_t len,
const uint8_t *salt, size_t salt_len, uint32_t i,
void SCRAM_SHA1_ClientKey(const uint8_t *password,
size_t len,
const uint8_t *salt,
size_t salt_len,
uint32_t i,
uint8_t *key)
{
uint8_t salted[SHA1_DIGEST_SIZE];
@@ -111,7 +119,8 @@ void SCRAM_SHA1_ClientKey(const uint8_t *password, size_t len,
}
void SCRAM_SHA1_ClientSignature(const uint8_t *ClientKey,
const uint8_t *AuthMessage, size_t len,
const uint8_t *AuthMessage,
size_t len,
uint8_t *sign)
{
uint8_t stored[SHA1_DIGEST_SIZE];

10
src/scram.h
View File

@@ -21,12 +21,16 @@
#include "sha1.h"
void SCRAM_SHA1_ClientKey(const uint8_t *password, size_t len,
const uint8_t *salt, size_t salt_len, uint32_t i,
void SCRAM_SHA1_ClientKey(const uint8_t *password,
size_t len,
const uint8_t *salt,
size_t salt_len,
uint32_t i,
uint8_t *key);
void SCRAM_SHA1_ClientSignature(const uint8_t *ClientKey,
const uint8_t *AuthMessage, size_t len,
const uint8_t *AuthMessage,
size_t len,
uint8_t *sign);
void SCRAM_SHA1_ClientProof(const uint8_t *ClientKey,

52
src/sha1.c
View File

@@ -86,16 +86,27 @@ static void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64]);
/* blk0() and blk() perform the initial expand. */
/* I got the idea of expanding during the round function from SSLeay */
#define blk0(i) (block->l[i] = host_to_be(block->l[i]))
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
^block->l[(i+2)&15]^block->l[i&15],1))
#define blk(i) \
(block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \
block->l[(i + 2) & 15] ^ block->l[i & 15], \
1))
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
#define R0(v, w, x, y, z, i) \
z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
w = rol(w, 30);
#define R1(v, w, x, y, z, i) \
z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
w = rol(w, 30);
#define R2(v, w, x, y, z, i) \
z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
w = rol(w, 30);
#define R3(v, w, x, y, z, i) \
z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
w = rol(w, 30);
#define R4(v, w, x, y, z, i) \
z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
w = rol(w, 30);
static uint32_t host_to_be(uint32_t i)
{
@@ -144,6 +155,7 @@ static void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
e = state[4];
/* 4 rounds of 20 operations each. Loop unrolled. */
/* clang-format off */
R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
@@ -164,6 +176,7 @@ static void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
/* clang-format on */
/* Add the working vars back into context.state[] */
state[0] += a;
@@ -176,7 +189,6 @@ static void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
a = b = c = d = e = 0;
}
/* SHA1Init - Initialize new context */
void crypto_SHA1_Init(SHA1_CTX *context)
{
@@ -189,9 +201,9 @@ void crypto_SHA1_Init(SHA1_CTX* context)
context->count[0] = context->count[1] = 0;
}
/* Run your data through this. */
void crypto_SHA1_Update(SHA1_CTX* context, const uint8_t* data,
void crypto_SHA1_Update(SHA1_CTX *context,
const uint8_t *data,
const size_t len)
{
size_t i, j;
@@ -207,12 +219,11 @@ void crypto_SHA1_Update(SHA1_CTX* context, const uint8_t* data,
SHA1_Transform(context->state, data + i);
}
j = 0;
}
else i = 0;
} else
i = 0;
memcpy(&context->buffer[j], &data[i], len - i);
}
/* Add padding and return the message digest. */
void crypto_SHA1_Final(SHA1_CTX *context, uint8_t *digest)
{
@@ -220,17 +231,19 @@ void crypto_SHA1_Final(SHA1_CTX* context, uint8_t* digest)
uint8_t finalcount[8];
for (i = 0; i < 8; i++) {
finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >>
((3 - (i & 3)) * 8)) &
255); /* Endian independent */
}
crypto_SHA1_Update(context, (uint8_t *)"\200", 1);
while ((context->count[0] & 504) != 448) {
crypto_SHA1_Update(context, (uint8_t *)"\0", 1);
}
crypto_SHA1_Update(context, finalcount, 8); /* Should cause a SHA1_Transform() */
crypto_SHA1_Update(context, finalcount,
8); /* Should cause a SHA1_Transform() */
for (i = 0; i < SHA1_DIGEST_SIZE; i++) {
digest[i] = (uint8_t)
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
digest[i] =
(uint8_t)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
}
/* Wipe variables */
@@ -244,7 +257,6 @@ void crypto_SHA1_Final(SHA1_CTX* context, uint8_t* digest)
#endif
}
void crypto_SHA1(const uint8_t *data, size_t len, uint8_t *digest)
{
SHA1_CTX ctx;

3
src/sha1.h
View File

@@ -24,7 +24,8 @@ typedef struct {
#define SHA1_DIGEST_SIZE 20
void crypto_SHA1_Init(SHA1_CTX *context);
void crypto_SHA1_Update(SHA1_CTX* context, const uint8_t* data,
void crypto_SHA1_Update(SHA1_CTX *context,
const uint8_t *data,
const size_t len);
void crypto_SHA1_Final(SHA1_CTX *context, uint8_t *digest);
void crypto_SHA1(const uint8_t *data, size_t len, uint8_t *digest);

232
src/snprintf.c
View File

@@ -85,14 +85,29 @@
#define LDOUBLE double
#endif
static int dopr (char *buffer, size_t maxlen, const char *format,
va_list args);
static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
char *value, int flags, int min, int max);
static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
long value, int base, int min, int max, int flags);
static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
LDOUBLE fvalue, int min, int max, int flags);
static int dopr(char *buffer, size_t maxlen, const char *format, va_list args);
static int fmtstr(char *buffer,
size_t *currlen,
size_t maxlen,
char *value,
int flags,
int min,
int max);
static int fmtint(char *buffer,
size_t *currlen,
size_t maxlen,
long value,
int base,
int min,
int max,
int flags);
static int fmtfp(char *buffer,
size_t *currlen,
size_t maxlen,
LDOUBLE fvalue,
int min,
int max,
int flags);
static int dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
/*
@@ -147,13 +162,11 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
ch = *format++;
total = 0;
while (state != DP_S_DONE)
{
while (state != DP_S_DONE) {
if (ch == '\0')
state = DP_S_DONE;
switch(state)
{
switch (state) {
case DP_S_DEFAULT:
if (ch == '%')
state = DP_S_FLAGS;
@@ -162,8 +175,7 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
ch = *format++;
break;
case DP_S_FLAGS:
switch (ch)
{
switch (ch) {
case '-':
flags |= DP_F_MINUS;
ch = *format++;
@@ -190,50 +202,39 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
}
break;
case DP_S_MIN:
if (isdigit(ch))
{
if (isdigit(ch)) {
min = 10 * min + char_to_int(ch);
ch = *format++;
}
else if (ch == '*')
{
} else if (ch == '*') {
min = va_arg(args, int);
ch = *format++;
state = DP_S_DOT;
}
else
} else
state = DP_S_DOT;
break;
case DP_S_DOT:
if (ch == '.')
{
if (ch == '.') {
state = DP_S_MAX;
ch = *format++;
}
else
} else
state = DP_S_MOD;
break;
case DP_S_MAX:
if (isdigit(ch))
{
if (isdigit(ch)) {
if (max < 0)
max = 0;
max = 10 * max + char_to_int(ch);
ch = *format++;
}
else if (ch == '*')
{
} else if (ch == '*') {
max = va_arg(args, int);
ch = *format++;
state = DP_S_MOD;
}
else
} else
state = DP_S_MOD;
break;
case DP_S_MOD:
/* Currently, we don't support Long Long, bummer */
switch (ch)
{
switch (ch) {
case 'h':
cflags = DP_C_SHORT;
ch = *format++;
@@ -252,8 +253,7 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
state = DP_S_CONV;
break;
case DP_S_CONV:
switch (ch)
{
switch (ch) {
case 'd':
case 'i':
if (cflags == DP_C_SHORT)
@@ -262,7 +262,8 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
value = va_arg(args, long int);
else
value = va_arg(args, int);
total += fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
total += fmtint(buffer, &currlen, maxlen, value, 10, min, max,
flags);
break;
case 'o':
flags |= DP_F_UNSIGNED;
@@ -272,7 +273,8 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
value = va_arg(args, unsigned long int);
else
value = va_arg(args, unsigned int);
total += fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
total +=
fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
break;
case 'u':
flags |= DP_F_UNSIGNED;
@@ -282,7 +284,8 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
value = va_arg(args, unsigned long int);
else
value = va_arg(args, unsigned int);
total += fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
total += fmtint(buffer, &currlen, maxlen, value, 10, min, max,
flags);
break;
case 'X':
flags |= DP_F_UP;
@@ -295,7 +298,8 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
value = va_arg(args, unsigned long int);
else
value = va_arg(args, unsigned int);
total += fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
total += fmtint(buffer, &currlen, maxlen, value, 16, min, max,
flags);
break;
case 'f':
if (cflags == DP_C_LDOUBLE)
@@ -303,7 +307,8 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
else
fvalue = va_arg(args, double);
/* um, floating point? */
total += fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
total +=
fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
break;
case 'E':
flags |= DP_F_UP;
@@ -324,32 +329,29 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
fvalue = va_arg(args, double);
break;
case 'c':
total += dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
total +=
dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
break;
case 's':
strvalue = va_arg(args, char *);
total += fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
total +=
fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
break;
case 'p':
strvalue = va_arg(args, void *);
total += fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min,
max, flags);
total += fmtint(buffer, &currlen, maxlen, (long)strvalue, 16,
min, max, flags);
break;
case 'n':
if (cflags == DP_C_SHORT)
{
if (cflags == DP_C_SHORT) {
short int *num;
num = va_arg(args, short int *);
*num = currlen;
}
else if (cflags == DP_C_LONG)
{
} else if (cflags == DP_C_LONG) {
long int *num;
num = va_arg(args, long int *);
*num = currlen;
}
else
{
} else {
int *num;
num = va_arg(args, int *);
*num = currlen;
@@ -378,8 +380,7 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
break; /* some picky compilers need this */
}
}
if (buffer != NULL && maxlen > 0)
{
if (buffer != NULL && maxlen > 0) {
if (currlen < maxlen - 1)
buffer[currlen] = '\0';
else
@@ -388,19 +389,24 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
return total;
}
static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
char *value, int flags, int min, int max)
static int fmtstr(char *buffer,
size_t *currlen,
size_t maxlen,
char *value,
int flags,
int min,
int max)
{
int padlen, strln; /* amount to pad */
int cnt = 0;
int total = 0;
if (value == 0)
{
if (value == 0) {
value = "<NULL>";
}
for (strln = 0; value[strln]; ++strln); /* strlen */
for (strln = 0; value[strln]; ++strln)
; /* strlen */
if (max >= 0 && max < strln)
strln = max;
padlen = min - strln;
@@ -409,18 +415,15 @@ static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
if (flags & DP_F_MINUS)
padlen = -padlen; /* Left Justify */
while (padlen > 0)
{
while (padlen > 0) {
total += dopr_outch(buffer, currlen, maxlen, ' ');
--padlen;
}
while (*value && ((max < 0) || (cnt < max)))
{
while (*value && ((max < 0) || (cnt < max))) {
total += dopr_outch(buffer, currlen, maxlen, *value++);
++cnt;
}
while (padlen < 0)
{
while (padlen < 0) {
total += dopr_outch(buffer, currlen, maxlen, ' ');
++padlen;
}
@@ -429,8 +432,14 @@ static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
long value, int base, int min, int max, int flags)
static int fmtint(char *buffer,
size_t *currlen,
size_t maxlen,
long value,
int base,
int min,
int max,
int flags)
{
int signvalue = 0;
unsigned long uvalue;
@@ -446,37 +455,35 @@ static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
uvalue = value;
if(!(flags & DP_F_UNSIGNED))
{
if (!(flags & DP_F_UNSIGNED)) {
if (value < 0) {
signvalue = '-';
uvalue = -value;
}
else
if (flags & DP_F_PLUS) /* Do a sign (+/i) */
} else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
signvalue = '+';
else
if (flags & DP_F_SPACE)
else if (flags & DP_F_SPACE)
signvalue = ' ';
}
if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
if (flags & DP_F_UP)
caps = 1; /* Should characters be upper case? */
do {
convert[place++] =
(caps? "0123456789ABCDEF":"0123456789abcdef")
[uvalue % (unsigned)base ];
convert[place++] = (caps ? "0123456789ABCDEF"
: "0123456789abcdef")[uvalue % (unsigned)base];
uvalue = (uvalue / (unsigned)base);
} while (uvalue && (place < 20));
if (place == 20) place--;
if (place == 20)
place--;
convert[place] = 0;
zpadlen = max - place;
spadlen = min - MAX(max, place) - (signvalue ? 1 : 0);
if (zpadlen < 0) zpadlen = 0;
if (spadlen < 0) spadlen = 0;
if (flags & DP_F_ZERO)
{
if (zpadlen < 0)
zpadlen = 0;
if (spadlen < 0)
spadlen = 0;
if (flags & DP_F_ZERO) {
zpadlen = MAX(zpadlen, spadlen);
spadlen = 0;
}
@@ -489,8 +496,7 @@ static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
#endif
/* Spaces */
while (spadlen > 0)
{
while (spadlen > 0) {
total += dopr_outch(buffer, currlen, maxlen, ' ');
--spadlen;
}
@@ -500,10 +506,8 @@ static int fmtint (char *buffer, size_t *currlen, size_t maxlen,
total += dopr_outch(buffer, currlen, maxlen, signvalue);
/* Zeros */
if (zpadlen > 0)
{
while (zpadlen > 0)
{
if (zpadlen > 0) {
while (zpadlen > 0) {
total += dopr_outch(buffer, currlen, maxlen, '0');
--zpadlen;
}
@@ -536,8 +540,7 @@ static LDOUBLE _snp_pow10 (int exp)
{
LDOUBLE result = 1;
while (exp)
{
while (exp) {
result *= 10;
exp--;
}
@@ -557,8 +560,13 @@ static long _snp_round (LDOUBLE value)
return intpart;
}
static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
LDOUBLE fvalue, int min, int max, int flags)
static int fmtfp(char *buffer,
size_t *currlen,
size_t maxlen,
LDOUBLE fvalue,
int min,
int max,
int flags)
{
int signvalue = 0;
LDOUBLE ufvalue;
@@ -584,11 +592,9 @@ static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
if (fvalue < 0)
signvalue = '-';
else
if (flags & DP_F_PLUS) /* Do a sign (+/i) */
else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
signvalue = '+';
else
if (flags & DP_F_SPACE)
else if (flags & DP_F_SPACE)
signvalue = ' ';
#if 0
@@ -609,8 +615,7 @@ static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
*/
fracpart = _snp_round((_snp_pow10(max)) * (ufvalue - intpart));
if (fracpart >= _snp_pow10 (max))
{
if (fracpart >= _snp_pow10(max)) {
intpart++;
fracpart -= _snp_pow10(max);
}
@@ -625,7 +630,8 @@ static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
(caps ? "0123456789ABCDEF" : "0123456789abcdef")[intpart % 10];
intpart = (intpart / 10);
} while (intpart && (iplace < 20));
if (iplace == 20) iplace--;
if (iplace == 20)
iplace--;
iconvert[iplace] = 0;
/* Convert fractional part */
@@ -634,7 +640,8 @@ static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
(caps ? "0123456789ABCDEF" : "0123456789abcdef")[fracpart % 10];
fracpart = (fracpart / 10);
} while (fracpart && (fplace < 20));
if (fplace == 20) fplace--;
if (fplace == 20)
fplace--;
fconvert[fplace] = 0;
/* -1 for decimal point, another -1 if we are printing a sign */
@@ -647,22 +654,18 @@ static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
if (flags & DP_F_MINUS)
padlen = -padlen; /* Left Justifty */
if ((flags & DP_F_ZERO) && (padlen > 0))
{
if (signvalue)
{
if ((flags & DP_F_ZERO) && (padlen > 0)) {
if (signvalue) {
total += dopr_outch(buffer, currlen, maxlen, signvalue);
--padlen;
signvalue = 0;
}
while (padlen > 0)
{
while (padlen > 0) {
total += dopr_outch(buffer, currlen, maxlen, '0');
--padlen;
}
}
while (padlen > 0)
{
while (padlen > 0) {
total += dopr_outch(buffer, currlen, maxlen, ' ');
--padlen;
}
@@ -676,22 +679,19 @@ static int fmtfp (char *buffer, size_t *currlen, size_t maxlen,
* Decimal point. This should probably use locale to find the correct
* char to print out.
*/
if (max > 0)
{
if (max > 0) {
total += dopr_outch(buffer, currlen, maxlen, '.');
while (fplace > 0)
total += dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
}
while (zpadlen > 0)
{
while (zpadlen > 0) {
total += dopr_outch(buffer, currlen, maxlen, '0');
--zpadlen;
}
while (padlen < 0)
{
while (padlen < 0) {
total += dopr_outch(buffer, currlen, maxlen, ' ');
++padlen;
}

24
src/sock.c
View File

@@ -123,7 +123,8 @@ int sock_set_keepalive(const sock_t sock, int timeout, int interval)
ka.onoff = optval;
ka.keepalivetime = timeout * 1000;
ka.keepaliveinterval = interval * 1000;
ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &ka, sizeof(ka), NULL, 0, &dw, NULL, NULL);
ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &ka, sizeof(ka), NULL, 0, &dw,
NULL, NULL);
#else
ret = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));
if (ret < 0)
@@ -131,15 +132,19 @@ int sock_set_keepalive(const sock_t sock, int timeout, int interval)
if (optval) {
#ifdef TCP_KEEPIDLE
ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &timeout, sizeof(timeout));
ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &timeout,
sizeof(timeout));
#elif defined(TCP_KEEPALIVE)
/* QNX receives `struct timeval' as argument, but it seems OSX does int */
ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPALIVE, &timeout, sizeof(timeout));
/* QNX receives `struct timeval' as argument, but it seems OSX does int
*/
ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPALIVE, &timeout,
sizeof(timeout));
#endif /* TCP_KEEPIDLE */
if (ret < 0)
return ret;
#ifdef TCP_KEEPINTVL
ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &interval, sizeof(interval));
ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &interval,
sizeof(interval));
if (ret < 0)
return ret;
#endif /* TCP_KEEPINTVL */
@@ -217,17 +222,18 @@ int sock_connect_error(const sock_t sock)
/* we don't actually care about the peer name, we're just checking if
* we're connected or not */
if (getpeername(sock, &sa, &len) == 0)
{
if (getpeername(sock, &sa, &len) == 0) {
return 0;
}
/* it's possible that the error wasn't ENOTCONN, so if it wasn't,
* return that */
#ifdef _WIN32
if (sock_error() != WSAENOTCONN) return sock_error();
if (sock_error() != WSAENOTCONN)
return sock_error();
#else
if (sock_error() != ENOTCONN) return sock_error();
if (sock_error() != ENOTCONN)
return sock_error();
#endif
/* load the correct error into errno through error slippage */

173
src/stanza.c
View File

@@ -82,11 +82,13 @@ static int _stanza_copy_attributes(xmpp_stanza_t * dst,
int rc = XMPP_EOK;
iter = hash_iter_new(src->attributes);
if (!iter) rc = XMPP_EMEM;
if (!iter)
rc = XMPP_EMEM;
while (rc == XMPP_EOK && (key = hash_iter_next(iter))) {
val = hash_get(src->attributes, key);
if (!val) rc = XMPP_EINT;
if (!val)
rc = XMPP_EINT;
if (rc == XMPP_EOK)
rc = xmpp_stanza_set_attribute(dst, key, val);
}
@@ -116,13 +118,15 @@ xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t * const stanza)
xmpp_stanza_t *copy, *child, *copychild, *tail;
copy = xmpp_stanza_new(stanza->ctx);
if (!copy) goto copy_error;
if (!copy)
goto copy_error;
copy->type = stanza->type;
if (stanza->data) {
copy->data = xmpp_strdup(stanza->ctx, stanza->data);
if (!copy->data) goto copy_error;
if (!copy->data)
goto copy_error;
}
if (stanza->attributes) {
@@ -133,7 +137,8 @@ xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t * const stanza)
tail = copy->children;
for (child = stanza->children; child; child = child->next) {
copychild = xmpp_stanza_copy(child);
if (!copychild) goto copy_error;
if (!copychild)
goto copy_error;
copychild->parent = copy;
if (tail) {
@@ -148,7 +153,8 @@ xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t * const stanza)
copy_error:
/* release all the hitherto allocated memory */
if (copy) xmpp_stanza_release(copy);
if (copy)
xmpp_stanza_release(copy);
return NULL;
}
@@ -179,8 +185,10 @@ int xmpp_stanza_release(xmpp_stanza_t * const stanza)
xmpp_stanza_release(tchild);
}
if (stanza->attributes) hash_release(stanza->attributes);
if (stanza->data) xmpp_free(stanza->ctx, stanza->data);
if (stanza->attributes)
hash_release(stanza->attributes);
if (stanza->data)
xmpp_free(stanza->ctx, stanza->data);
xmpp_free(stanza->ctx, stanza);
released = 1;
}
@@ -286,9 +294,11 @@ static char *_escape_xml(xmpp_ctx_t * const ctx, char *text)
}
/* small helper function */
static void _render_update(int *written, const int length,
static void _render_update(int *written,
const int length,
const int lastwrite,
size_t *left, char **ptr)
size_t *left,
char **ptr)
{
*written += lastwrite;
@@ -307,7 +317,8 @@ static void _render_update(int *written, const int length,
* and return values > buflen indicate buffer was not large enough
*/
static int _render_stanza_recursive(xmpp_stanza_t *stanza,
char * const buf, size_t const buflen)
char *const buf,
size_t const buflen)
{
char *ptr = buf;
size_t left = buflen;
@@ -319,23 +330,29 @@ static int _render_stanza_recursive(xmpp_stanza_t *stanza,
written = 0;
if (stanza->type == XMPP_STANZA_UNKNOWN) return XMPP_EINVOP;
if (stanza->type == XMPP_STANZA_UNKNOWN)
return XMPP_EINVOP;
if (stanza->type == XMPP_STANZA_TEXT) {
if (!stanza->data) return XMPP_EINVOP;
if (!stanza->data)
return XMPP_EINVOP;
tmp = _escape_xml(stanza->ctx, stanza->data);
if (tmp == NULL) return XMPP_EMEM;
if (tmp == NULL)
return XMPP_EMEM;
ret = xmpp_snprintf(ptr, left, "%s", tmp);
xmpp_free(stanza->ctx, tmp);
if (ret < 0) return XMPP_EMEM;
if (ret < 0)
return XMPP_EMEM;
_render_update(&written, buflen, ret, &left, &ptr);
} else { /* stanza->type == XMPP_STANZA_TAG */
if (!stanza->data) return XMPP_EINVOP;
if (!stanza->data)
return XMPP_EINVOP;
/* write beginning of tag and attributes */
ret = xmpp_snprintf(ptr, left, "<%s", stanza->data);
if (ret < 0) return XMPP_EMEM;
if (ret < 0)
return XMPP_EMEM;
_render_update(&written, buflen, ret, &left, &ptr);
if (stanza->attributes && hash_num_keys(stanza->attributes) > 0) {
@@ -343,10 +360,10 @@ static int _render_stanza_recursive(xmpp_stanza_t *stanza,
while ((key = hash_iter_next(iter))) {
if (!strcmp(key, "xmlns")) {
/* don't output namespace if parent stanza is the same */
if (stanza->parent &&
stanza->parent->attributes &&
if (stanza->parent && stanza->parent->attributes &&
hash_get(stanza->parent->attributes, key) &&
!strcmp((char*)hash_get(stanza->attributes, key),
!strcmp(
(char *)hash_get(stanza->attributes, key),
(char *)hash_get(stanza->parent->attributes, key)))
continue;
/* or if this is the stream namespace */
@@ -375,21 +392,24 @@ static int _render_stanza_recursive(xmpp_stanza_t *stanza,
if (!stanza->children) {
/* write end if singleton tag */
ret = xmpp_snprintf(ptr, left, "/>");
if (ret < 0) return XMPP_EMEM;
if (ret < 0)
return XMPP_EMEM;
_render_update(&written, buflen, ret, &left, &ptr);
} else {
/* this stanza has child stanzas */
/* write end of start tag */
ret = xmpp_snprintf(ptr, left, ">");
if (ret < 0) return XMPP_EMEM;
if (ret < 0)
return XMPP_EMEM;
_render_update(&written, buflen, ret, &left, &ptr);
/* iterate and recurse over child stanzas */
child = stanza->children;
while (child) {
ret = _render_stanza_recursive(child, ptr, left);
if (ret < 0) return ret;
if (ret < 0)
return ret;
_render_update(&written, buflen, ret, &left, &ptr);
@@ -398,7 +418,8 @@ static int _render_stanza_recursive(xmpp_stanza_t *stanza,
/* write end tag */
ret = xmpp_snprintf(ptr, left, "</%s>", stanza->data);
if (ret < 0) return XMPP_EMEM;
if (ret < 0)
return XMPP_EMEM;
_render_update(&written, buflen, ret, &left, &ptr);
}
@@ -485,12 +506,13 @@ int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
*
* @ingroup Stanza
*/
int xmpp_stanza_set_name(xmpp_stanza_t *stanza,
const char * const name)
int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *const name)
{
if (stanza->type == XMPP_STANZA_TEXT) return XMPP_EINVOP;
if (stanza->type == XMPP_STANZA_TEXT)
return XMPP_EINVOP;
if (stanza->data) xmpp_free(stanza->ctx, stanza->data);
if (stanza->data)
xmpp_free(stanza->ctx, stanza->data);
stanza->type = XMPP_STANZA_TAG;
stanza->data = xmpp_strdup(stanza->ctx, name);
@@ -510,7 +532,8 @@ int xmpp_stanza_set_name(xmpp_stanza_t *stanza,
*/
const char *xmpp_stanza_get_name(xmpp_stanza_t *const stanza)
{
if (stanza->type == XMPP_STANZA_TEXT) return NULL;
if (stanza->type == XMPP_STANZA_TEXT)
return NULL;
return stanza->data;
}
@@ -546,7 +569,8 @@ int xmpp_stanza_get_attribute_count(xmpp_stanza_t * const stanza)
* @ingroup Stanza
*/
int xmpp_stanza_get_attributes(xmpp_stanza_t *const stanza,
const char **attr, int attrlen)
const char **attr,
int attrlen)
{
hash_iterator_t *iter;
const char *key;
@@ -593,11 +617,13 @@ int xmpp_stanza_set_attribute(xmpp_stanza_t * const stanza,
char *val;
int rc;
if (stanza->type != XMPP_STANZA_TAG) return XMPP_EINVOP;
if (stanza->type != XMPP_STANZA_TAG)
return XMPP_EINVOP;
if (!stanza->attributes) {
stanza->attributes = hash_new(stanza->ctx, 8, xmpp_free);
if (!stanza->attributes) return XMPP_EMEM;
if (!stanza->attributes)
return XMPP_EMEM;
}
val = xmpp_strdup(stanza->ctx, value);
@@ -625,8 +651,7 @@ int xmpp_stanza_set_attribute(xmpp_stanza_t * const stanza,
*
* @ingroup Stanza
*/
int xmpp_stanza_set_ns(xmpp_stanza_t * const stanza,
const char * const ns)
int xmpp_stanza_set_ns(xmpp_stanza_t *const stanza, const char *const ns)
{
return xmpp_stanza_set_attribute(stanza, "xmlns", ns);
}
@@ -646,7 +671,8 @@ int xmpp_stanza_set_ns(xmpp_stanza_t * const stanza,
*
* @ingroup Stanza
*/
int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza, xmpp_stanza_t *child,
int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza,
xmpp_stanza_t *child,
int do_clone)
{
xmpp_stanza_t *s;
@@ -662,7 +688,8 @@ int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza, xmpp_stanza_t *child,
stanza->children = child;
else {
s = stanza->children;
while (s->next) s = s->next;
while (s->next)
s = s->next;
s->next = child;
child->prev = s;
}
@@ -699,14 +726,15 @@ int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child)
*
* @ingroup Stanza
*/
int xmpp_stanza_set_text(xmpp_stanza_t *stanza,
const char * const text)
int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *const text)
{
if (stanza->type == XMPP_STANZA_TAG) return XMPP_EINVOP;
if (stanza->type == XMPP_STANZA_TAG)
return XMPP_EINVOP;
stanza->type = XMPP_STANZA_TEXT;
if (stanza->data) xmpp_free(stanza->ctx, stanza->data);
if (stanza->data)
xmpp_free(stanza->ctx, stanza->data);
stanza->data = xmpp_strdup(stanza->ctx, text);
return stanza->data == NULL ? XMPP_EMEM : XMPP_EOK;
@@ -730,13 +758,16 @@ int xmpp_stanza_set_text_with_size(xmpp_stanza_t *stanza,
const char *const text,
const size_t size)
{
if (stanza->type == XMPP_STANZA_TAG) return XMPP_EINVOP;
if (stanza->type == XMPP_STANZA_TAG)
return XMPP_EINVOP;
stanza->type = XMPP_STANZA_TEXT;
if (stanza->data) xmpp_free(stanza->ctx, stanza->data);
if (stanza->data)
xmpp_free(stanza->ctx, stanza->data);
stanza->data = xmpp_alloc(stanza->ctx, size + 1);
if (!stanza->data) return XMPP_EMEM;
if (!stanza->data)
return XMPP_EMEM;
memcpy(stanza->data, text, size);
stanza->data[size] = 0;
@@ -962,10 +993,12 @@ char *xmpp_stanza_get_text(xmpp_stanza_t * const stanza)
if (child->type == XMPP_STANZA_TEXT)
len += strlen(child->data);
if (len == 0) return NULL;
if (len == 0)
return NULL;
text = (char *)xmpp_alloc(stanza->ctx, len + 1);
if (!text) return NULL;
if (!text)
return NULL;
len = 0;
for (child = stanza->children; child; child = child->next)
@@ -1012,8 +1045,7 @@ const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t * const stanza)
*
* @ingroup Stanza
*/
int xmpp_stanza_set_id(xmpp_stanza_t * const stanza,
const char * const id)
int xmpp_stanza_set_id(xmpp_stanza_t *const stanza, const char *const id)
{
return xmpp_stanza_set_attribute(stanza, "id", id);
}
@@ -1029,8 +1061,7 @@ int xmpp_stanza_set_id(xmpp_stanza_t * const stanza,
*
* @ingroup Stanza
*/
int xmpp_stanza_set_type(xmpp_stanza_t * const stanza,
const char * const type)
int xmpp_stanza_set_type(xmpp_stanza_t *const stanza, const char *const type)
{
return xmpp_stanza_set_attribute(stanza, "type", type);
}
@@ -1047,8 +1078,7 @@ int xmpp_stanza_set_type(xmpp_stanza_t * const stanza,
*
* @ingroup Stanza
*/
int xmpp_stanza_set_to(xmpp_stanza_t * const stanza,
const char * const to)
int xmpp_stanza_set_to(xmpp_stanza_t *const stanza, const char *const to)
{
return xmpp_stanza_set_attribute(stanza, "to", to);
}
@@ -1065,8 +1095,7 @@ int xmpp_stanza_set_to(xmpp_stanza_t * const stanza,
*
* @ingroup Stanza
*/
int xmpp_stanza_set_from(xmpp_stanza_t * const stanza,
const char * const from)
int xmpp_stanza_set_from(xmpp_stanza_t *const stanza, const char *const from)
{
return xmpp_stanza_set_attribute(stanza, "from", from);
}
@@ -1134,16 +1163,19 @@ xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t * const stanza)
int rc;
from = xmpp_stanza_get_from(stanza);
if (!from) goto copy_error;
if (!from)
goto copy_error;
copy = xmpp_stanza_new(stanza->ctx);
if (!copy) goto copy_error;
if (!copy)
goto copy_error;
copy->type = stanza->type;
if (stanza->data) {
copy->data = xmpp_strdup(stanza->ctx, stanza->data);
if (!copy->data) goto copy_error;
if (!copy->data)
goto copy_error;
}
if (stanza->attributes) {
@@ -1154,18 +1186,21 @@ xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t * const stanza)
xmpp_stanza_del_attribute(copy, "to");
xmpp_stanza_del_attribute(copy, "from");
rc = xmpp_stanza_set_to(copy, from);
if (rc != XMPP_EOK) goto copy_error;
if (rc != XMPP_EOK)
goto copy_error;
return copy;
copy_error:
if (copy) xmpp_stanza_release(copy);
if (copy)
xmpp_stanza_release(copy);
return NULL;
}
static xmpp_stanza_t *
_stanza_new_with_attrs(xmpp_ctx_t *ctx, const char * const name,
const char * const type, const char * const id,
static xmpp_stanza_t *_stanza_new_with_attrs(xmpp_ctx_t *ctx,
const char *const name,
const char *const type,
const char *const id,
const char *const to)
{
xmpp_stanza_t *stanza = xmpp_stanza_new(ctx);
@@ -1199,8 +1234,10 @@ _stanza_new_with_attrs(xmpp_ctx_t *ctx, const char * const name,
*
* @ingroup Stanza
*/
xmpp_stanza_t *xmpp_message_new(xmpp_ctx_t *ctx, const char * const type,
const char * const to, const char * const id)
xmpp_stanza_t *xmpp_message_new(xmpp_ctx_t *ctx,
const char *const type,
const char *const to,
const char *const id)
{
return _stanza_new_with_attrs(ctx, "message", type, id, to);
}
@@ -1285,8 +1322,8 @@ int xmpp_message_set_body(xmpp_stanza_t *msg, const char * const text)
*
* @ingroup Stanza
*/
xmpp_stanza_t *xmpp_iq_new(xmpp_ctx_t *ctx, const char * const type,
const char * const id)
xmpp_stanza_t *
xmpp_iq_new(xmpp_ctx_t *ctx, const char *const type, const char *const id)
{
return _stanza_new_with_attrs(ctx, "iq", type, id, NULL);
}
@@ -1317,10 +1354,12 @@ xmpp_stanza_t *xmpp_presence_new(xmpp_ctx_t *ctx)
*
* @ingroup Stanza
*/
xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx, xmpp_error_type_t const type,
xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx,
xmpp_error_type_t const type,
const char *const text)
{
xmpp_stanza_t *error = _stanza_new_with_attrs(ctx, "stream:error", NULL, NULL, NULL);
xmpp_stanza_t *error =
_stanza_new_with_attrs(ctx, "stream:error", NULL, NULL, NULL);
xmpp_stanza_t *error_type = xmpp_stanza_new(ctx);
switch (type) {

4
src/tls_gnutls.c
View File

@@ -79,8 +79,8 @@ int tls_set_credentials(tls_t *tls, const char *cafilename)
int err;
/* set trusted credentials -- takes a .pem filename */
err = gnutls_certificate_set_x509_trust_file(tls->cred,
cafilename, GNUTLS_X509_FMT_PEM);
err = gnutls_certificate_set_x509_trust_file(tls->cred, cafilename,
GNUTLS_X509_FMT_PEM);
if (err >= 0) {
err = gnutls_credentials_set(tls->session, GNUTLS_CRD_CERTIFICATE,
tls->cred);

21
src/tls_openssl.c
View File

@@ -169,9 +169,11 @@ tls_t *tls_new(xmpp_conn_t *conn)
* Allow only complete wildcards. RFC 6125 discourages wildcard usage
* completely, and lists internationalized domain names as a reason
* against partial wildcards.
* See https://tools.ietf.org/html/rfc6125#section-7.2 for more information.
* See https://tools.ietf.org/html/rfc6125#section-7.2 for more
* information.
*/
X509_VERIFY_PARAM_set_hostflags(param, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
X509_VERIFY_PARAM_set_hostflags(param,
X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
X509_VERIFY_PARAM_set1_host(param, conn->domain, 0);
#endif
@@ -271,10 +273,9 @@ int tls_stop(tls_t *tls)
int tls_is_recoverable(int error)
{
return (error == SSL_ERROR_NONE || error == SSL_ERROR_WANT_READ
|| error == SSL_ERROR_WANT_WRITE
|| error == SSL_ERROR_WANT_CONNECT
|| error == SSL_ERROR_WANT_ACCEPT);
return (error == SSL_ERROR_NONE || error == SSL_ERROR_WANT_READ ||
error == SSL_ERROR_WANT_WRITE || error == SSL_ERROR_WANT_CONNECT ||
error == SSL_ERROR_WANT_ACCEPT);
}
int tls_pending(tls_t *tls)
@@ -315,7 +316,8 @@ static void _tls_sock_wait(tls_t *tls, int error)
int nfds;
int ret;
if (error == SSL_ERROR_NONE) return;
if (error == SSL_ERROR_NONE)
return;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
@@ -323,8 +325,9 @@ static void _tls_sock_wait(tls_t *tls, int error)
FD_SET(tls->sock, &rfds);
if (error == SSL_ERROR_WANT_WRITE)
FD_SET(tls->sock, &wfds);
nfds = (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE) ?
tls->sock + 1 : 0;
nfds = (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)
? tls->sock + 1
: 0;
do {
tv.tv_sec = TLS_TIMEOUT_SEC;
tv.tv_usec = TLS_TIMEOUT_USEC;

110
src/tls_schannel.c
View File

@@ -118,8 +118,7 @@ tls_t *tls_new(xmpp_conn_t *conn)
ret = tls->sft->QuerySecurityPackageInfo(UNISP_NAME, &(tls->spi));
if (ret != SEC_E_OK)
{
if (ret != SEC_E_OK) {
tls_free(tls);
return NULL;
}
@@ -140,11 +139,11 @@ tls_t *tls_new(xmpp_conn_t *conn)
(void)algs;
#endif
ret = tls->sft->AcquireCredentialsHandleA(NULL, UNISP_NAME,
SECPKG_CRED_OUTBOUND, NULL, &scred, NULL, NULL, &(tls->hcred), NULL);
ret = tls->sft->AcquireCredentialsHandleA(
NULL, UNISP_NAME, SECPKG_CRED_OUTBOUND, NULL, &scred, NULL, NULL,
&(tls->hcred), NULL);
if (ret != SEC_E_OK)
{
if (ret != SEC_E_OK) {
tls_free(tls);
return NULL;
}
@@ -155,23 +154,23 @@ tls_t *tls_new(xmpp_conn_t *conn)
/* This bunch of queries should trip up wine until someone fixes
* schannel support there */
ret = tls->sft->QueryCredentialsAttributes(&(tls->hcred), SECPKG_ATTR_SUPPORTED_ALGS, &spc_sa);
if (ret != SEC_E_OK)
{
ret = tls->sft->QueryCredentialsAttributes(
&(tls->hcred), SECPKG_ATTR_SUPPORTED_ALGS, &spc_sa);
if (ret != SEC_E_OK) {
tls_free(tls);
return NULL;
}
ret = tls->sft->QueryCredentialsAttributes(&(tls->hcred), SECPKG_ATTR_CIPHER_STRENGTHS, &spc_cs);
if (ret != SEC_E_OK)
{
ret = tls->sft->QueryCredentialsAttributes(
&(tls->hcred), SECPKG_ATTR_CIPHER_STRENGTHS, &spc_cs);
if (ret != SEC_E_OK) {
tls_free(tls);
return NULL;
}
ret = tls->sft->QueryCredentialsAttributes(&(tls->hcred), SECPKG_ATTR_SUPPORTED_PROTOCOLS, &spc_sp);
if (ret != SEC_E_OK)
{
ret = tls->sft->QueryCredentialsAttributes(
&(tls->hcred), SECPKG_ATTR_SUPPORTED_PROTOCOLS, &spc_sp);
if (ret != SEC_E_OK) {
tls_free(tls);
return NULL;
}
@@ -225,10 +224,10 @@ int tls_start(tls_t *tls)
/* use the domain there as our name */
name = tls->conn->domain;
ctxtreq = ISC_REQ_SEQUENCE_DETECT | ISC_REQ_REPLAY_DETECT
| ISC_REQ_CONFIDENTIALITY | ISC_RET_EXTENDED_ERROR
| ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_STREAM
| ISC_REQ_MANUAL_CRED_VALIDATION | ISC_REQ_INTEGRITY;
ctxtreq = ISC_REQ_SEQUENCE_DETECT | ISC_REQ_REPLAY_DETECT |
ISC_REQ_CONFIDENTIALITY | ISC_RET_EXTENDED_ERROR |
ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_STREAM |
ISC_REQ_MANUAL_CRED_VALIDATION | ISC_REQ_INTEGRITY;
memset(&(sbout[0]), 0, sizeof(sbout[0]));
sbout[0].BufferType = SECBUFFER_TOKEN;
@@ -251,16 +250,16 @@ int tls_start(tls_t *tls)
sbdin.cBuffers = 2;
sbdin.pBuffers = sbin;
ret = tls->sft->InitializeSecurityContextA(&(tls->hcred), NULL, name, ctxtreq, 0, 0,
NULL, 0, &(tls->hctxt), &sbdout,
&ctxtattr, NULL);
ret = tls->sft->InitializeSecurityContextA(
&(tls->hcred), NULL, name, ctxtreq, 0, 0, NULL, 0, &(tls->hctxt),
&sbdout, &ctxtattr, NULL);
unsigned char *p = sbin[0].pvBuffer;
int len = 0;
while (ret == SEC_I_CONTINUE_NEEDED
|| ret == SEC_I_INCOMPLETE_CREDENTIALS
|| ret == SEC_E_INCOMPLETE_MESSAGE) {
while (ret == SEC_I_CONTINUE_NEEDED ||
ret == SEC_I_INCOMPLETE_CREDENTIALS ||
ret == SEC_E_INCOMPLETE_MESSAGE) {
int inbytes = 0;
if (ret != SEC_E_INCOMPLETE_MESSAGE) {
@@ -275,9 +274,7 @@ int tls_start(tls_t *tls)
sent = sock_write(tls->sock, writebuff, writelen);
if (sent == -1) {
tls->lasterror = sock_error();
}
else
{
} else {
writebuff += sent;
writelen -= sent;
}
@@ -319,20 +316,16 @@ int tls_start(tls_t *tls)
if (inbytes > 0) {
len += inbytes;
p += inbytes;
}
else
{
} else {
tls->lasterror = sock_error();
}
}
sbin[0].cbBuffer = len;
ret = tls->sft->InitializeSecurityContextA(&(tls->hcred), &(tls->hctxt), name,
ctxtreq, 0, 0, &sbdin, 0,
&(tls->hctxt), &sbdout,
&ctxtattr, NULL);
ret = tls->sft->InitializeSecurityContextA(
&(tls->hcred), &(tls->hctxt), name, ctxtreq, 0, 0, &sbdin, 0,
&(tls->hctxt), &sbdout, &ctxtattr, NULL);
}
if (ret == SEC_E_OK) {
@@ -342,9 +335,7 @@ int tls_start(tls_t *tls)
sent = sock_write(tls->sock, writebuff, writelen);
if (sent == -1) {
tls->lasterror = sock_error();
}
else
{
} else {
writebuff += sent;
writelen -= sent;
}
@@ -358,20 +349,21 @@ int tls_start(tls_t *tls)
if (ret != SEC_E_OK) {
tls->lasterror = ret;
xmpp_error(tls->ctx, "TLSS", "Schannel error 0x%lx", (unsigned long)ret);
xmpp_error(tls->ctx, "TLSS", "Schannel error 0x%lx",
(unsigned long)ret);
return 0;
}
tls->sft->QueryContextAttributes(&(tls->hctxt), SECPKG_ATTR_STREAM_SIZES,
&(tls->spcss));
tls->recvbuffermaxlen = tls->spcss.cbHeader + tls->spcss.cbMaximumMessage
+ tls->spcss.cbTrailer;
tls->recvbuffermaxlen = tls->spcss.cbHeader + tls->spcss.cbMaximumMessage +
tls->spcss.cbTrailer;
tls->recvbuffer = xmpp_alloc(tls->ctx, tls->recvbuffermaxlen);
tls->recvbufferpos = 0;
tls->sendbuffermaxlen = tls->spcss.cbHeader + tls->spcss.cbMaximumMessage
+ tls->spcss.cbTrailer;
tls->sendbuffermaxlen = tls->spcss.cbHeader + tls->spcss.cbMaximumMessage +
tls->spcss.cbTrailer;
tls->sendbuffer = xmpp_alloc(tls->ctx, tls->sendbuffermaxlen);
tls->sendbufferpos = 0;
tls->sendbufferlen = 0;
@@ -395,12 +387,13 @@ int tls_error(tls_t *tls)
int tls_is_recoverable(int error)
{
return (error == SEC_E_OK || error == SEC_E_INCOMPLETE_MESSAGE
|| error == WSAEWOULDBLOCK || error == WSAEMSGSIZE
|| error == WSAEINPROGRESS);
return (error == SEC_E_OK || error == SEC_E_INCOMPLETE_MESSAGE ||
error == WSAEWOULDBLOCK || error == WSAEMSGSIZE ||
error == WSAEINPROGRESS);
}
int tls_pending(tls_t *tls) {
int tls_pending(tls_t *tls)
{
// There are 3 cases:
// - there is data in ready buffer, so it is by default pending
// - there is data in recv buffer. If it is not decrypted yet, means it
@@ -421,8 +414,7 @@ int tls_read(tls_t *tls, void * const buff, const size_t len)
int bytes;
/* first, if we've got some ready data, put that in the buffer */
if (tls->readybufferpos < tls->readybufferlen)
{
if (tls->readybufferpos < tls->readybufferlen) {
if (len < tls->readybufferlen - tls->readybufferpos) {
bytes = len;
} else {
@@ -519,8 +511,7 @@ int tls_read(tls_t *tls, void * const buff, const size_t len)
return -1;
} else if (ret == SEC_I_RENEGOTIATE) {
ret = tls_start(tls);
if (!ret)
{
if (!ret) {
return -1;
}
@@ -542,8 +533,7 @@ int tls_read(tls_t *tls, void * const buff, const size_t len)
int tls_clear_pending_write(tls_t *tls)
{
if (tls->sendbufferpos < tls->sendbufferlen)
{
if (tls->sendbufferpos < tls->sendbufferlen) {
int bytes;
bytes = sock_write(tls->sock, tls->sendbuffer + tls->sendbufferpos,
@@ -601,23 +591,22 @@ int tls_write(tls_t *tls, const void * const buff, const size_t len)
sbenc[1].pvBuffer = tls->sendbuffer + tls->spcss.cbHeader;
while (remain > 0)
{
while (remain > 0) {
if (remain > tls->spcss.cbMaximumMessage) {
sbenc[1].cbBuffer = tls->spcss.cbMaximumMessage;
} else {
sbenc[1].cbBuffer = remain;
}
sbenc[2].pvBuffer = (unsigned char *)sbenc[1].pvBuffer
+ sbenc[1].cbBuffer;
sbenc[2].pvBuffer =
(unsigned char *)sbenc[1].pvBuffer + sbenc[1].cbBuffer;
sbenc[2].cbBuffer = tls->spcss.cbTrailer;
memcpy(sbenc[1].pvBuffer, p, sbenc[1].cbBuffer);
p += tls->spcss.cbMaximumMessage;
tls->sendbufferlen = sbenc[0].cbBuffer + sbenc[1].cbBuffer
+ sbenc[2].cbBuffer;
tls->sendbufferlen =
sbenc[0].cbBuffer + sbenc[1].cbBuffer + sbenc[2].cbBuffer;
ret = tls->sft->EncryptMessage(&(tls->hctxt), 0, &sbdenc, 0);
@@ -645,7 +634,6 @@ int tls_write(tls_t *tls, const void * const buff, const size_t len)
if (ret == 0 || (ret == -1 && tls_is_recoverable(tls_error(tls)))) {
return sent;
}
}
return sent;

81
strophe.h
View File

@@ -140,11 +140,7 @@ typedef enum {
XMPP_LEVEL_ERROR
} xmpp_log_level_t;
typedef enum {
XMPP_UNKNOWN,
XMPP_CLIENT,
XMPP_COMPONENT
} xmpp_conn_type_t;
typedef enum { XMPP_UNKNOWN, XMPP_CLIENT, XMPP_COMPONENT } xmpp_conn_type_t;
typedef void (*xmpp_log_handler)(void *const userdata,
const xmpp_log_level_t level,
@@ -225,7 +221,9 @@ typedef void (*xmpp_conn_handler)(xmpp_conn_t * const conn,
xmpp_stream_error_t *const stream_error,
void *const userdata);
void xmpp_send_error(xmpp_conn_t * const conn, xmpp_error_type_t const type, char * const text);
void xmpp_send_error(xmpp_conn_t *const conn,
xmpp_error_type_t const type,
char *const text);
xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t *const ctx);
xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t *const conn);
int xmpp_conn_release(xmpp_conn_t *const conn);
@@ -240,7 +238,9 @@ void xmpp_conn_set_pass(xmpp_conn_t * const conn, const char * const pass);
xmpp_ctx_t *xmpp_conn_get_context(xmpp_conn_t *const conn);
void xmpp_conn_disable_tls(xmpp_conn_t *const conn);
int xmpp_conn_is_secured(xmpp_conn_t *const conn);
void xmpp_conn_set_keepalive(xmpp_conn_t * const conn, int timeout, int interval);
void xmpp_conn_set_keepalive(xmpp_conn_t *const conn,
int timeout,
int interval);
int xmpp_conn_is_connecting(xmpp_conn_t *const conn);
int xmpp_conn_is_connected(xmpp_conn_t *const conn);
int xmpp_conn_is_disconnected(xmpp_conn_t *const conn);
@@ -251,8 +251,10 @@ int xmpp_connect_client(xmpp_conn_t * const conn,
xmpp_conn_handler callback,
void *const userdata);
int xmpp_connect_component(xmpp_conn_t * const conn, const char * const server,
unsigned short port, xmpp_conn_handler callback,
int xmpp_connect_component(xmpp_conn_t *const conn,
const char *const server,
unsigned short port,
xmpp_conn_handler callback,
void *const userdata);
int xmpp_connect_raw(xmpp_conn_t *const conn,
@@ -261,20 +263,19 @@ int xmpp_connect_raw(xmpp_conn_t * const conn,
xmpp_conn_handler callback,
void *const userdata);
int xmpp_conn_open_stream_default(xmpp_conn_t *const conn);
int xmpp_conn_open_stream(xmpp_conn_t * const conn, char **attributes,
int xmpp_conn_open_stream(xmpp_conn_t *const conn,
char **attributes,
size_t attributes_len);
int xmpp_conn_tls_start(xmpp_conn_t *const conn);
void xmpp_disconnect(xmpp_conn_t *const conn);
void xmpp_send(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza);
void xmpp_send(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza);
void xmpp_send_raw_string(xmpp_conn_t * const conn,
const char * const fmt, ...);
void xmpp_send_raw_string(xmpp_conn_t *const conn, const char *const fmt, ...);
void xmpp_send_raw(xmpp_conn_t *const conn,
const char * const data, const size_t len);
const char *const data,
const size_t len);
/* handlers */
@@ -289,7 +290,6 @@ void xmpp_timed_handler_add(xmpp_conn_t * const conn,
void xmpp_timed_handler_delete(xmpp_conn_t *const conn,
xmpp_timed_handler handler);
/* if the handler returns false it is removed */
typedef int (*xmpp_handler)(xmpp_conn_t *const conn,
xmpp_stanza_t *const stanza,
@@ -301,8 +301,7 @@ void xmpp_handler_add(xmpp_conn_t * const conn,
const char *const name,
const char *const type,
void *const userdata);
void xmpp_handler_delete(xmpp_conn_t * const conn,
xmpp_handler handler);
void xmpp_handler_delete(xmpp_conn_t *const conn, xmpp_handler handler);
void xmpp_id_handler_add(xmpp_conn_t *const conn,
xmpp_handler handler,
@@ -337,7 +336,8 @@ int xmpp_stanza_is_tag(xmpp_stanza_t * const stanza);
/* marshall a stanza into text for transmission or display */
int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
char ** const buf, size_t * const buflen);
char **const buf,
size_t *const buflen);
xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t *const stanza);
xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t *const stanza,
@@ -349,14 +349,16 @@ xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t * const stanza
const char *const ns);
xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t *const stanza);
int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child);
int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza, xmpp_stanza_t *child,
int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza,
xmpp_stanza_t *child,
int do_clone);
const char *xmpp_stanza_get_attribute(xmpp_stanza_t *const stanza,
const char *const name);
int xmpp_stanza_get_attribute_count(xmpp_stanza_t *const stanza);
int xmpp_stanza_get_attributes(xmpp_stanza_t *const stanza,
const char **attr, int attrlen);
const char **attr,
int attrlen);
/* concatenate all child text nodes. this function
* returns a string that must be freed by the caller */
char *xmpp_stanza_get_text(xmpp_stanza_t *const stanza);
@@ -366,10 +368,8 @@ const char *xmpp_stanza_get_name(xmpp_stanza_t * const stanza);
int xmpp_stanza_set_attribute(xmpp_stanza_t *const stanza,
const char *const key,
const char *const value);
int xmpp_stanza_set_name(xmpp_stanza_t *stanza,
const char * const name);
int xmpp_stanza_set_text(xmpp_stanza_t *stanza,
const char * const text);
int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *const name);
int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *const text);
int xmpp_stanza_set_text_with_size(xmpp_stanza_t *stanza,
const char *const text,
const size_t size);
@@ -392,21 +392,25 @@ int xmpp_stanza_set_from(xmpp_stanza_t * const stanza, const char * const from);
xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t *const stanza);
/* stanza subclasses */
xmpp_stanza_t *xmpp_message_new(xmpp_ctx_t *ctx, const char * const type,
const char * const to, const char * const id);
xmpp_stanza_t *xmpp_message_new(xmpp_ctx_t *ctx,
const char *const type,
const char *const to,
const char *const id);
char *xmpp_message_get_body(xmpp_stanza_t *msg);
int xmpp_message_set_body(xmpp_stanza_t *msg, const char *const text);
xmpp_stanza_t *xmpp_iq_new(xmpp_ctx_t *ctx, const char * const type,
const char * const id);
xmpp_stanza_t *
xmpp_iq_new(xmpp_ctx_t *ctx, const char *const type, const char *const id);
xmpp_stanza_t *xmpp_presence_new(xmpp_ctx_t *ctx);
xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx, xmpp_error_type_t const type,
xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx,
xmpp_error_type_t const type,
const char *const text);
/* jid */
/* these return new strings that must be xmpp_free()'d */
char *xmpp_jid_new(xmpp_ctx_t *ctx, const char *node,
char *xmpp_jid_new(xmpp_ctx_t *ctx,
const char *node,
const char *domain,
const char *resource);
char *xmpp_jid_bare(xmpp_ctx_t *ctx, const char *jid);
@@ -435,7 +439,8 @@ char *xmpp_uuid_gen(xmpp_ctx_t *ctx);
typedef struct _xmpp_sha1_t xmpp_sha1_t;
char *xmpp_sha1(xmpp_ctx_t *ctx, const unsigned char *data, size_t len);
void xmpp_sha1_digest(const unsigned char *data, size_t len,
void xmpp_sha1_digest(const unsigned char *data,
size_t len,
unsigned char *digest);
xmpp_sha1_t *xmpp_sha1_new(xmpp_ctx_t *ctx);
@@ -448,10 +453,14 @@ void xmpp_sha1_to_digest(xmpp_sha1_t *sha1, unsigned char *digest);
/* Base64 */
char *xmpp_base64_encode(xmpp_ctx_t *ctx, const unsigned char *data, size_t len);
char *
xmpp_base64_encode(xmpp_ctx_t *ctx, const unsigned char *data, size_t len);
char *xmpp_base64_decode_str(xmpp_ctx_t *ctx, const char *base64, size_t len);
void xmpp_base64_decode_bin(xmpp_ctx_t *ctx, const char *base64, size_t len,
unsigned char **out, size_t *outlen);
void xmpp_base64_decode_bin(xmpp_ctx_t *ctx,
const char *base64,
size_t len,
unsigned char **out,
size_t *outlen);
#ifdef __cplusplus
}

17
strophepp.h
View File

@@ -18,8 +18,10 @@
#include "strophe.h"
namespace XMPP {
class Context {
namespace XMPP
{
class Context
{
private:
xmpp_mem_t m_mem;
xmpp_log_t m_log;
@@ -40,8 +42,7 @@ namespace XMPP {
private:
static void *callAlloc(const size_t size, void *const userdata);
static void *callRealloc(void *p, const size_t size,
void * const userdata);
static void *callRealloc(void *p, const size_t size, void *const userdata);
static void callFree(void *p, void *const userdata);
static void callLog(void *const userdata,
const xmpp_log_level_t level,
@@ -49,7 +50,8 @@ namespace XMPP {
const char *const msg);
};
class Stanza {
class Stanza
{
private:
Context *m_ctx;
xmpp_stanza_t *m_stanza;
@@ -89,7 +91,8 @@ namespace XMPP {
void setFrom(const char *const from);
};
class Connection {
class Connection
{
private:
Context *m_ctx;
xmpp_conn_t *conn;
@@ -128,6 +131,6 @@ namespace XMPP {
void *const userdata);
void deleteIdHandler(xmpp_handler handler);
};
}
} // namespace XMPP
#endif /* __LIBSTROPHE_STROPHEPP_H__ */

11
tests/check_parser.c
View File

@@ -18,11 +18,12 @@
#include "test.h"
#define fail_unless(expr) do { \
#define fail_unless(expr) \
do { \
int result = (expr); \
if (!result) { \
printf("%s:%d: Assertion failed: %s\n", \
__FILE__, __LINE__, #expr); \
printf("%s:%d: Assertion failed: %s\n", __FILE__, __LINE__, \
#expr); \
exit(1); \
} \
} while (0)
@@ -67,9 +68,7 @@ static void callbacks(void)
int ret;
ctx = xmpp_ctx_new(NULL, NULL);
parser = parser_new(ctx,
cbtest_handle_start,
cbtest_handle_end,
parser = parser_new(ctx, cbtest_handle_start, cbtest_handle_end,
cbtest_handle_stanza, NULL);
ret = parser_feed(parser, "<stream>", 8);

4
tests/res_query_dump.c
View File

@@ -55,8 +55,8 @@ int main(int argc, char **argv)
}
domain = argv[1];
snprintf(fulldomain, sizeof(fulldomain), "_%s._%s.%s",
service, proto, domain);
snprintf(fulldomain, sizeof(fulldomain), "_%s._%s.%s", service, proto,
domain);
errno = 0;
len = res_query(fulldomain, C_IN, T_SRV, buf, sizeof(buf));

6
tests/test.c
View File

@@ -16,9 +16,9 @@
static uint8_t char_to_bin(char c)
{
return c <= '9' ? (uint8_t)(c - '0') :
c <= 'Z' ? (uint8_t)(c - 'A' + 10) :
(uint8_t)(c - 'a' + 10);
return c <= '9'
? (uint8_t)(c - '0')
: c <= 'Z' ? (uint8_t)(c - 'A' + 10) : (uint8_t)(c - 'a' + 10);
}
void test_hex_to_bin(const char *hex, uint8_t *bin, size_t *bin_len)

13
tests/test.h
View File

@@ -18,7 +18,8 @@
#include "ostypes.h"
#define TEST_MAIN \
int main(int argc, char **argv) { \
int main(int argc, char **argv) \
{ \
int num_failed; \
Suite *s = parser_suite(); \
SRunner *sr = srunner_create(s); \
@@ -51,14 +52,10 @@ do { \
const uint8_t *__v2 = (uint8_t *)(v2); \
size_t __len1 = len1; \
size_t __len2 = len2; \
if (__len1 != __len2 || \
memcmp(__v1, __v2, __len1) != 0) \
{ \
if (__len1 != __len2 || memcmp(__v1, __v2, __len1) != 0) { \
printf("%s differs!\n", #v1); \
printf("expected: 0x%s\n", \
test_bin_to_hex(__v1, __len1)); \
printf("got: 0x%s\n", \
test_bin_to_hex(__v2, __len2)); \
printf("expected: 0x%s\n", test_bin_to_hex(__v1, __len1)); \
printf("got: 0x%s\n", test_bin_to_hex(__v2, __len2)); \
exit(1); \
} \
} while (0)

75
tests/test_base64.c
View File

@@ -17,11 +17,11 @@
#include "test.h"
static const unsigned char test_2_raw[] =
{0x14, 0xfb, 0x9c, 0x03, 0xd9, 0x7e, 0x00};
static const unsigned char test_4_raw[] =
{0xd6, 0x2f, 0x27, 0x49, 0x7e, 0xdd, 0xf3, 0xd5,
0x41, 0xbc, 0x1b, 0xe9, 0xdf, 0xe9, 0xb3, 0x08, 0x00};
static const unsigned char test_2_raw[] = {0x14, 0xfb, 0x9c, 0x03,
0xd9, 0x7e, 0x00};
static const unsigned char test_4_raw[] = {0xd6, 0x2f, 0x27, 0x49, 0x7e, 0xdd,
0xf3, 0xd5, 0x41, 0xbc, 0x1b, 0xe9,
0xdf, 0xe9, 0xb3, 0x08, 0x00};
static const struct {
char *raw;
@@ -36,13 +36,11 @@ static const struct {
.base64 = "FPucA9l+",
},
{
.raw =
"From rest and sleep, which but thy pictures be, "
.raw = "From rest and sleep, which but thy pictures be, "
"Much pleasure; then from thee much more must flow, "
"And soonest our best men with thee do go, "
"Rest of their bones, and soul's delivery.",
.base64 =
"RnJvbSByZXN0IGFuZCBzbGVlcCwgd2hpY2ggYnV0IHRoeSBwaWN0dXJl"
.base64 = "RnJvbSByZXN0IGFuZCBzbGVlcCwgd2hpY2ggYnV0IHRoeSBwaWN0dXJl"
"cyBiZSwgTXVjaCBwbGVhc3VyZTsgdGhlbiBmcm9tIHRoZWUgbXVjaCBt"
"b3JlIG11c3QgZmxvdywgQW5kIHNvb25lc3Qgb3VyIGJlc3QgbWVuIHdp"
"dGggdGhlZSBkbyBnbywgUmVzdCBvZiB0aGVpciBib25lcywgYW5kIHNv"
@@ -53,11 +51,9 @@ static const struct {
.base64 = "1i8nSX7d89VBvBvp3+mzCA==",
},
{
.raw =
"realm=\"chesspark.com\",nonce=\"b243c0d663257a9149999cef2f83"
.raw = "realm=\"chesspark.com\",nonce=\"b243c0d663257a9149999cef2f83"
"a22116559e93\",qop=\"auth\",charset=utf-8,algorithm=md5-sess",
.base64 =
"cmVhbG09ImNoZXNzcGFyay5jb20iLG5vbmNlPSJiMjQzYzBkNjYzMjU3"
.base64 = "cmVhbG09ImNoZXNzcGFyay5jb20iLG5vbmNlPSJiMjQzYzBkNjYzMjU3"
"YTkxNDk5OTljZWYyZjgzYTIyMTE2NTU5ZTkzIixxb3A9ImF1dGgiLGNo"
"YXJzZXQ9dXRmLTgsYWxnb3JpdGhtPW1kNS1zZXNz",
},
@@ -94,38 +90,27 @@ static const struct {
};
static const unsigned char bin_data[] = {
0xda, 0xa8, 0x81, 0x80, 0x00, 0x01, 0x00, 0x05,
0x00, 0x00, 0x00, 0x00, 0x0c, 0x5f, 0x78, 0x6d,
0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x67,
0x6d, 0x61, 0x69, 0x6c, 0x03, 0x63, 0x6f, 0x6d,
0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c, 0x00,
0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00,
0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04,
0x61, 0x6c, 0x74, 0x31, 0x04, 0x78, 0x6d, 0x70,
0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0xc0,
0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14,
0x66, 0x04, 0x61, 0x6c, 0x74, 0x34, 0x04, 0x78,
0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f,
0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d,
0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00,
0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x32,
0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00,
0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x19, 0x00,
0x05, 0x00, 0x00, 0x14, 0x66, 0x04, 0x78, 0x6d,
0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f,
0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00,
0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00,
0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00,
0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x33, 0x04,
0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f,
0x6d, 0x00,
0xda, 0xa8, 0x81, 0x80, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x67, 0x6d, 0x61, 0x69, 0x6c,
0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c, 0x00,
0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x31, 0x04, 0x78, 0x6d, 0x70,
0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04, 0x61, 0x6c,
0x74, 0x34, 0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f,
0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00,
0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x32, 0x04, 0x78, 0x6d, 0x70,
0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
0x43, 0x00, 0x19, 0x00, 0x05, 0x00, 0x00, 0x14, 0x66, 0x04, 0x78, 0x6d,
0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03,
0x63, 0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00,
0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04, 0x61,
0x6c, 0x74, 0x33, 0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00,
};
int main(int argc, char *argv[])

16
tests/test_ctx.c
View File

@@ -1,5 +1,6 @@
/* test_ctx.c
** libstrophe XMPP client library -- test routines for the library run-time context
** libstrophe XMPP client library -- test routines for the library run-time
*context
**
** Copyright (C) 2005-2009 Collecta, Inc.
**
@@ -39,11 +40,13 @@ void *my_realloc(void *p, const size_t size, void * const userdata)
return realloc(p, size);
}
void my_logger(void * const userdata, const xmpp_log_level_t level,
const char * const area, const char * const msg)
void my_logger(void *const userdata,
const xmpp_log_level_t level,
const char *const area,
const char *const msg)
{
if (strcmp((char *)userdata, "asdf") == 0 && level == XMPP_LEVEL_DEBUG
&& strcmp(area, "test") == 0 && strcmp(msg, "hello") == 0)
if (strcmp((char *)userdata, "asdf") == 0 && level == XMPP_LEVEL_DEBUG &&
strcmp(area, "test") == 0 && strcmp(msg, "hello") == 0)
log_called++;
}
@@ -56,7 +59,8 @@ int main(int argc, char **argv)
void *testptr1, *testptr2;
ctx = xmpp_ctx_new(NULL, NULL);
if (ctx == NULL) return 1;
if (ctx == NULL)
return 1;
/* destroy context */
xmpp_ctx_free(ctx);

38
tests/test_hash.c
View File

@@ -22,12 +22,8 @@
#define TESTSIZE 500
/* static test data */
const char *keys[] = {
"foo", "bar", "baz", "quux", "xyzzy"
};
const char *values[] = {
"wuzzle", "mug", "canonical", "rosebud", "lottery"
};
const char *keys[] = {"foo", "bar", "baz", "quux", "xyzzy"};
const char *values[] = {"wuzzle", "mug", "canonical", "rosebud", "lottery"};
const int nkeys = ARRAY_SIZE(keys);
int main(int argc, char **argv)
@@ -68,7 +64,8 @@ int main(int argc, char **argv)
/* test insertion */
for (i = 0; i < nkeys; i++) {
err = hash_add(table, keys[i], xmpp_strdup(ctx, values[i]));
if (err) return err;
if (err)
return err;
}
/* test key count */
@@ -80,11 +77,15 @@ int main(int argc, char **argv)
/* test replacing old values */
for (i = 0; i < nkeys; i++) {
err = hash_add(table, keys[0], xmpp_strdup(ctx, values[i]));
if (err) return err;
if (hash_num_keys(table) != nkeys) return 1;
if (err)
return err;
if (hash_num_keys(table) != nkeys)
return 1;
result = hash_get(table, keys[0]);
if (result == NULL) return 1;
if (strcmp(result, values[i]) != 0) return 1;
if (result == NULL)
return 1;
if (strcmp(result, values[i]) != 0)
return 1;
}
/* restore value for the 1st key */
hash_add(table, keys[0], xmpp_strdup(ctx, values[0]));
@@ -132,14 +133,19 @@ int main(int argc, char **argv)
/* test drops */
hash_drop(clone, keys[2]);
if (hash_get(clone, keys[2]) != NULL) return 1;
if (hash_get(clone, keys[2]) != NULL)
return 1;
hash_drop(clone, keys[1]);
hash_drop(clone, keys[4]);
if (hash_get(clone, keys[4]) != NULL) return 1;
if (hash_get(clone, keys[1]) != NULL) return 1;
if (hash_get(clone, keys[4]) != NULL)
return 1;
if (hash_get(clone, keys[1]) != NULL)
return 1;
/* keys 0,3 should still be available */
if (hash_get(clone, keys[0]) == NULL) return 1;
if (hash_get(clone, keys[3]) == NULL) return 1;
if (hash_get(clone, keys[0]) == NULL)
return 1;
if (hash_get(clone, keys[3]) == NULL)
return 1;
/* release our clone */
hash_release(clone);

136
tests/test_jid.c
View File

@@ -36,61 +36,93 @@ int test_jid(xmpp_ctx_t *ctx)
node = xmpp_jid_node(ctx, jid1);
domain = xmpp_jid_domain(ctx, jid1);
resource = xmpp_jid_resource(ctx, jid1);
printf("jid '%s' parsed to %s, %s, %s\n",
jid1, _s(node), _s(domain), _s(resource));
if (bare == NULL || strcmp(bare, "foo@bar.com")) return 1;
if (node == NULL || strcmp(node, "foo")) return 1;
if (domain == NULL || strcmp(domain, "bar.com")) return 1;
if (resource != NULL) return 1;
if (bare) xmpp_free(ctx, bare);
if (node) xmpp_free(ctx, node);
if (domain) xmpp_free(ctx, domain);
if (resource) xmpp_free(ctx, resource);
printf("jid '%s' parsed to %s, %s, %s\n", jid1, _s(node), _s(domain),
_s(resource));
if (bare == NULL || strcmp(bare, "foo@bar.com"))
return 1;
if (node == NULL || strcmp(node, "foo"))
return 1;
if (domain == NULL || strcmp(domain, "bar.com"))
return 1;
if (resource != NULL)
return 1;
if (bare)
xmpp_free(ctx, bare);
if (node)
xmpp_free(ctx, node);
if (domain)
xmpp_free(ctx, domain);
if (resource)
xmpp_free(ctx, resource);
bare = xmpp_jid_bare(ctx, jid2);
node = xmpp_jid_node(ctx, jid2);
domain = xmpp_jid_domain(ctx, jid2);
resource = xmpp_jid_resource(ctx, jid2);
printf("jid '%s' parsed to %s, %s, %s\n",
jid2, _s(node), _s(domain), _s(resource));
if (bare == NULL || strcmp(bare, "anyone@example.com")) return 1;
if (node == NULL || strcmp(node, "anyone")) return 1;
if (domain == NULL || strcmp(domain, "example.com")) return 1;
if (resource == NULL || strcmp(resource, "hullo")) return 1;
if (bare) xmpp_free(ctx, bare);
if (node) xmpp_free(ctx, node);
if (domain) xmpp_free(ctx, domain);
if (resource) xmpp_free(ctx, resource);
printf("jid '%s' parsed to %s, %s, %s\n", jid2, _s(node), _s(domain),
_s(resource));
if (bare == NULL || strcmp(bare, "anyone@example.com"))
return 1;
if (node == NULL || strcmp(node, "anyone"))
return 1;
if (domain == NULL || strcmp(domain, "example.com"))
return 1;
if (resource == NULL || strcmp(resource, "hullo"))
return 1;
if (bare)
xmpp_free(ctx, bare);
if (node)
xmpp_free(ctx, node);
if (domain)
xmpp_free(ctx, domain);
if (resource)
xmpp_free(ctx, resource);
bare = xmpp_jid_bare(ctx, jid3);
node = xmpp_jid_node(ctx, jid3);
domain = xmpp_jid_domain(ctx, jid3);
resource = xmpp_jid_resource(ctx, jid3);
printf("jid '%s' parsed to %s, %s, %s\n",
jid3, _s(node), _s(domain), _s(resource));
if (bare == NULL || strcmp(bare, "manic.porter@xyz.net")) return 1;
if (node == NULL || strcmp(node, "manic.porter")) return 1;
if (domain == NULL || strcmp(domain, "xyz.net")) return 1;
if (resource == NULL || strcmp(resource, "frob")) return 1;
if (bare) xmpp_free(ctx, bare);
if (node) xmpp_free(ctx, node);
if (domain) xmpp_free(ctx, domain);
if (resource) xmpp_free(ctx, resource);
printf("jid '%s' parsed to %s, %s, %s\n", jid3, _s(node), _s(domain),
_s(resource));
if (bare == NULL || strcmp(bare, "manic.porter@xyz.net"))
return 1;
if (node == NULL || strcmp(node, "manic.porter"))
return 1;
if (domain == NULL || strcmp(domain, "xyz.net"))
return 1;
if (resource == NULL || strcmp(resource, "frob"))
return 1;
if (bare)
xmpp_free(ctx, bare);
if (node)
xmpp_free(ctx, node);
if (domain)
xmpp_free(ctx, domain);
if (resource)
xmpp_free(ctx, resource);
bare = xmpp_jid_bare(ctx, jid4);
node = xmpp_jid_node(ctx, jid4);
domain = xmpp_jid_domain(ctx, jid4);
resource = xmpp_jid_resource(ctx, jid4);
printf("jid '%s' parsed to %s, %s, %s\n",
jid4, _s(node), _s(domain), _s(resource));
if (bare == NULL || strcmp(bare, "domain.tld")) return 1;
if (node != NULL) return 1;
if (domain == NULL || strcmp(domain, "domain.tld")) return 1;
if (resource != NULL) return 1;
if (bare) xmpp_free(ctx, bare);
if (node) xmpp_free(ctx, node);
if (domain) xmpp_free(ctx, domain);
if (resource) xmpp_free(ctx, resource);
printf("jid '%s' parsed to %s, %s, %s\n", jid4, _s(node), _s(domain),
_s(resource));
if (bare == NULL || strcmp(bare, "domain.tld"))
return 1;
if (node != NULL)
return 1;
if (domain == NULL || strcmp(domain, "domain.tld"))
return 1;
if (resource != NULL)
return 1;
if (bare)
xmpp_free(ctx, bare);
if (node)
xmpp_free(ctx, node);
if (domain)
xmpp_free(ctx, domain);
if (resource)
xmpp_free(ctx, resource);
return 0;
}
@@ -101,12 +133,14 @@ int test_jid_new(xmpp_ctx_t *ctx)
jid = xmpp_jid_new(ctx, "node", "domain", "resource");
printf("new jid: '%s'\n", jid);
if (strcmp(jid, "node@domain/resource")) return 1;
if (strcmp(jid, "node@domain/resource"))
return 1;
xmpp_free(ctx, jid);
jid = xmpp_jid_new(ctx, "foo", "bar.com", NULL);
printf("new jid: '%s'\n", jid);
if (strcmp(jid, "foo@bar.com")) return 1;
if (strcmp(jid, "foo@bar.com"))
return 1;
xmpp_free(ctx, jid);
return 0;
@@ -119,20 +153,26 @@ int main(int argc, char *argv[])
printf("allocating context... ");
ctx = xmpp_ctx_new(NULL, NULL);
if (ctx == NULL) printf("failed to create context\n");
if (ctx == NULL) return -1;
if (ctx == NULL)
printf("failed to create context\n");
if (ctx == NULL)
return -1;
printf("ok.\n");
printf("testing jid routines...\n");
ret = test_jid(ctx);
if (ret) printf("testing jid routines... failed!\n");
if (ret) return ret;
if (ret)
printf("testing jid routines... failed!\n");
if (ret)
return ret;
printf("testing jid routines... ok.\n");
printf("testing jid new routines...\n");
ret = test_jid_new(ctx);
if (ret) printf("testing jid new routines... failed!\n");
if (ret) return ret;
if (ret)
printf("testing jid new routines... failed!\n");
if (ret)
return ret;
printf("testing jid new routines... ok.\n");
printf("freeing context... ");

13
tests/test_rand.c
View File

@@ -21,14 +21,17 @@
#include "rand.c"
/* stubs to build test without whole libstrophe */
void *xmpp_alloc(const xmpp_ctx_t * const ctx, const size_t size) {
void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size)
{
return NULL;
}
void xmpp_free(const xmpp_ctx_t *const ctx, void *p) {}
int xmpp_snprintf (char *str, size_t count, const char *fmt, ...) {
int xmpp_snprintf(char *str, size_t count, const char *fmt, ...)
{
return 0;
}
uint64_t time_stamp(void) {
uint64_t time_stamp(void)
{
return 0;
}
@@ -121,8 +124,8 @@ int main()
&entropy_input_len);
test_hex_to_bin(test_vectors[i].nonce, nonce, &nonce_len);
Hash_DRBG_Instantiate(&ctx, entropy_input, entropy_input_len,
nonce, nonce_len);
Hash_DRBG_Instantiate(&ctx, entropy_input, entropy_input_len, nonce,
nonce_len);
COMPARE(test_vectors[i].V1, test_bin_to_hex(ctx.V, sizeof(ctx.V)));
COMPARE(test_vectors[i].C1, test_bin_to_hex(ctx.C, sizeof(ctx.C)));
assert(ctx.reseed_counter == 1);

122
tests/test_resolver.c
View File

@@ -19,71 +19,51 @@
/* res_query("_xmpp-client._tcp.jabber.kiev.ua", C_IN, T_SRV, ...) */
static const unsigned char data1[] = {
0x95, 0xf3, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01,
0x00, 0x00, 0x00, 0x00, 0x0c, 0x5f, 0x78, 0x6d,
0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a,
0x61, 0x62, 0x62, 0x65, 0x72, 0x04, 0x6b, 0x69,
0x65, 0x76, 0x02, 0x75, 0x61, 0x00, 0x00, 0x21,
0x00, 0x01, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01,
0x00, 0x00, 0x00, 0x3b, 0x00, 0x16, 0x00, 0x01,
0x00, 0x00, 0x14, 0x66, 0x06, 0x6a, 0x61, 0x62,
0x62, 0x65, 0x72, 0x04, 0x6b, 0x69, 0x65, 0x76,
0x02, 0x75, 0x61, 0x00,
0x95, 0xf3, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a, 0x61, 0x62, 0x62, 0x65,
0x72, 0x04, 0x6b, 0x69, 0x65, 0x76, 0x02, 0x75, 0x61, 0x00, 0x00, 0x21,
0x00, 0x01, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3b,
0x00, 0x16, 0x00, 0x01, 0x00, 0x00, 0x14, 0x66, 0x06, 0x6a, 0x61, 0x62,
0x62, 0x65, 0x72, 0x04, 0x6b, 0x69, 0x65, 0x76, 0x02, 0x75, 0x61, 0x00,
};
/* res_query("_xmpp-client._tcp.jabber.org", C_IN, T_SRV, ...) */
static const unsigned char data2[] = {
0xf2, 0x98, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x0c, 0x5f, 0x78, 0x6d,
0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a,
0x61, 0x62, 0x62, 0x65, 0x72, 0x03, 0x6f, 0x72,
0x67, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c,
0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83,
0x00, 0x1a, 0x00, 0x1e, 0x00, 0x1e, 0x14, 0x66,
0x07, 0x68, 0x65, 0x72, 0x6d, 0x65, 0x73, 0x32,
0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x03,
0x6f, 0x72, 0x67, 0x00, 0xc0, 0x0c, 0x00, 0x21,
0x00, 0x01, 0x00, 0x00, 0x03, 0x83, 0x00, 0x1c,
0x00, 0x1f, 0x00, 0x1e, 0x14, 0x66, 0x09, 0x68,
0x65, 0x72, 0x6d, 0x65, 0x73, 0x32, 0x76, 0x36,
0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x03,
0xf2, 0x98, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a, 0x61, 0x62, 0x62, 0x65,
0x72, 0x03, 0x6f, 0x72, 0x67, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c,
0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83, 0x00, 0x1a, 0x00, 0x1e,
0x00, 0x1e, 0x14, 0x66, 0x07, 0x68, 0x65, 0x72, 0x6d, 0x65, 0x73, 0x32,
0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x03, 0x6f, 0x72, 0x67, 0x00,
0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83, 0x00, 0x1c,
0x00, 0x1f, 0x00, 0x1e, 0x14, 0x66, 0x09, 0x68, 0x65, 0x72, 0x6d, 0x65,
0x73, 0x32, 0x76, 0x36, 0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x03,
0x6f, 0x72, 0x67, 0x00,
};
/* res_query("_xmpp-client._tcp.gmail.com", C_IN, T_SRV, ...) */
static const unsigned char data3[] = {
0xda, 0xa8, 0x81, 0x80, 0x00, 0x01, 0x00, 0x05,
0x00, 0x00, 0x00, 0x00, 0x0c, 0x5f, 0x78, 0x6d,
0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x67,
0x6d, 0x61, 0x69, 0x6c, 0x03, 0x63, 0x6f, 0x6d,
0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c, 0x00,
0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00,
0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04,
0x61, 0x6c, 0x74, 0x31, 0x04, 0x78, 0x6d, 0x70,
0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67,
0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0xc0,
0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14,
0x66, 0x04, 0x61, 0x6c, 0x74, 0x34, 0x04, 0x78,
0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f,
0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d,
0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00,
0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x32,
0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00,
0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x19, 0x00,
0x05, 0x00, 0x00, 0x14, 0x66, 0x04, 0x78, 0x6d,
0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f,
0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00,
0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00,
0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00,
0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x33, 0x04,
0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f,
0x6d, 0x00,
0xda, 0xa8, 0x81, 0x80, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x67, 0x6d, 0x61, 0x69, 0x6c,
0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c, 0x00,
0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x31, 0x04, 0x78, 0x6d, 0x70,
0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04, 0x61, 0x6c,
0x74, 0x34, 0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f,
0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00,
0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x32, 0x04, 0x78, 0x6d, 0x70,
0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
0x43, 0x00, 0x19, 0x00, 0x05, 0x00, 0x00, 0x14, 0x66, 0x04, 0x78, 0x6d,
0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03,
0x63, 0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00,
0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04, 0x61,
0x6c, 0x74, 0x33, 0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00,
};
/* res_query("_xmpp-client._tcp.jabber.calyxinstitute.org", C_IN, T_SRV, ...) */
static const unsigned char data4[] = {
@@ -119,17 +99,14 @@ static const unsigned char data5[] = {
};
/* hacked data2 with two empty-string targets. */
static const unsigned char data6[] = {
0xf2, 0x98, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02,
0x00, 0x00, 0x00, 0x00, 0x0c, 0x5f, 0x78, 0x6d,
0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a,
0x61, 0x62, 0x62, 0x65, 0x72, 0x03, 0x6f, 0x72,
0x67, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c,
0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83,
0x00, 0x07, 0x00, 0x1e, 0x00, 0x1e, 0x14, 0x66,
0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00,
0x00, 0x03, 0x83, 0x00, 0x08, 0x00, 0x1f, 0x00,
0x1e, 0x14, 0x66, 0xc0, 0x40,
0xf2, 0x98, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00,
0x00, 0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69,
0x65, 0x6e, 0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a, 0x61,
0x62, 0x62, 0x65, 0x72, 0x03, 0x6f, 0x72, 0x67, 0x00, 0x00, 0x21,
0x00, 0x01, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03,
0x83, 0x00, 0x07, 0x00, 0x1e, 0x00, 0x1e, 0x14, 0x66, 0x00, 0xc0,
0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83, 0x00, 0x08,
0x00, 0x1f, 0x00, 0x1e, 0x14, 0x66, 0xc0, 0x40,
};
static const struct {
@@ -187,7 +164,8 @@ static int srv_rr_list_len(resolver_srv_rr_t *list)
{
int nr;
for (nr = 0; list != NULL; ++nr, list = list->next);
for (nr = 0; list != NULL; ++nr, list = list->next)
;
return nr;
}
@@ -223,8 +201,8 @@ int main(int argc, char **argv)
port = srv_rr_list->port;
COMPARE(tests[i].target, domain);
if (tests[i].port != port) {
printf("fail! got port=%u, but should be %u\n",
(unsigned)port, (unsigned)tests[i].port);
printf("fail! got port=%u, but should be %u\n", (unsigned)port,
(unsigned)tests[i].port);
return 1;
}
printf("ok\n");

22
tests/test_sasl.c
View File

@@ -69,8 +69,8 @@ int test_digest_md5(xmpp_ctx_t *ctx)
{
char *result;
result = sasl_digest_md5(ctx, challenge_md5,
"somenode@somerealm", "secret");
result =
sasl_digest_md5(ctx, challenge_md5, "somenode@somerealm", "secret");
printf("response:\n%s\n", result);
if (strcmp(response_md5, result)) {
/* generated incorrect response to challenge */
@@ -87,20 +87,26 @@ int main(int argc, char *argv[])
printf("allocating context... ");
ctx = xmpp_ctx_new(NULL, NULL);
if (ctx == NULL) printf("failed to create context\n");
if (ctx == NULL) return -1;
if (ctx == NULL)
printf("failed to create context\n");
if (ctx == NULL)
return -1;
printf("ok.\n");
printf("testing SASL PLAIN... ");
ret = test_plain(ctx);
if (ret) printf("failed!\n");
if (ret) return ret;
if (ret)
printf("failed!\n");
if (ret)
return ret;
printf("ok.\n");
printf("testing SASL DIGEST-MD5... ");
ret = test_digest_md5(ctx);
if (ret) printf("failed!\n");
if (ret) return ret;
if (ret)
printf("failed!\n");
if (ret)
return ret;
printf("ok.\n");
printf("freeing context... ");

9
tests/test_scram.c
View File

@@ -115,14 +115,13 @@ static void test_scram(void)
printf("SCRAM_SHA1_ClientKey and SCRAM_SHA1_ClientSignature tests.\n");
for (i = 0; i < ARRAY_SIZE(scram_vectors); ++i) {
printf("Test #%d: ", (int)i + 1);
snprintf(auth, sizeof(auth), "%s,%s,%s",
scram_vectors[i].initial + 3, scram_vectors[i].challenge,
scram_vectors[i].response);
snprintf(auth, sizeof(auth), "%s,%s,%s", scram_vectors[i].initial + 3,
scram_vectors[i].challenge, scram_vectors[i].response);
test_hex_to_bin(scram_vectors[i].salt, salt, &salt_len);
SCRAM_SHA1_ClientKey((uint8_t *)scram_vectors[i].password,
strlen(scram_vectors[i].password),
salt, salt_len, scram_vectors[i].i, key);
strlen(scram_vectors[i].password), salt, salt_len,
scram_vectors[i].i, key);
SCRAM_SHA1_ClientSignature(key, (uint8_t *)auth, strlen(auth), sign);
for (j = 0; j < SHA1_DIGEST_SIZE; j++) {
sign[j] ^= key[j];

6
tests/test_sha1.c
View File

@@ -12,13 +12,11 @@
/* Test Vectors (from FIPS PUB 180-1) */
static char *test_data[] = {
"abc",
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
"abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
"A million repetitions of 'a'",
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"};
static char *test_results[] = {
"A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D",
static char *test_results[] = {"A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D",
"84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1",
"34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F",
"AD5B3FDB CB526778 C2839D2F 151EA753 995E26A0"};

58
tests/test_snprintf.c
View File

@@ -20,38 +20,14 @@ int main (void)
{
char buf1[LONG_STRING];
char buf2[LONG_STRING];
char *fp_fmt[] = {
"%-1.5f",
"%1.5f",
"%123.9f",
"%10.5f",
"% 10.5f",
"%+22.9f",
"%+4.9f",
"%01.3f",
"%4f",
"%3.1f",
"%3.2f",
"%.0f",
"%.1f",
NULL
};
double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996,
0.9996, 1.996, 4.136, 0};
char *int_fmt[] = {
"%-1.5d",
"%1.5d",
"%123.9d",
"%5.5d",
"%10.5d",
"% 10.5d",
"%+22.33d",
"%01.3d",
"%4d",
"0x%x",
"0x%04x",
NULL
};
char *fp_fmt[] = {"%-1.5f", "%1.5f", "%123.9f", "%10.5f", "% 10.5f",
"%+22.9f", "%+4.9f", "%01.3f", "%4f", "%3.1f",
"%3.2f", "%.0f", "%.1f", NULL};
double fp_nums[] = {-1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96,
0.996, 0.9996, 1.996, 4.136, 0};
char *int_fmt[] = {"%-1.5d", "%1.5d", "%123.9d", "%5.5d",
"%10.5d", "% 10.5d", "%+22.33d", "%01.3d",
"%4d", "0x%x", "0x%04x", NULL};
long int_nums[] = {-1, 134, 91340, 341, 0203, 0x76543210, 0};
int x, y;
int fail = 0;
@@ -60,13 +36,12 @@ int main (void)
printf("Testing xmpp_snprintf format codes against system sprintf...\n");
for (x = 0; fp_fmt[x] != NULL; x++)
for (y = 0; fp_nums[y] != 0 ; y++)
{
for (y = 0; fp_nums[y] != 0; y++) {
xmpp_snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
sprintf(buf2, fp_fmt[x], fp_nums[y]);
if (strcmp (buf1, buf2))
{
printf("xmpp_snprintf doesn't match Format: %s\n\txmpp_snprintf = %s\n\tsprintf = %s\n",
if (strcmp(buf1, buf2)) {
printf("xmpp_snprintf doesn't match Format: "
"%s\n\txmpp_snprintf = %s\n\tsprintf = %s\n",
fp_fmt[x], buf1, buf2);
fail++;
}
@@ -74,13 +49,12 @@ int main (void)
}
for (x = 0; int_fmt[x] != NULL; x++)
for (y = 0; int_nums[y] != 0 ; y++)
{
for (y = 0; int_nums[y] != 0; y++) {
xmpp_snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
sprintf(buf2, int_fmt[x], int_nums[y]);
if (strcmp (buf1, buf2))
{
printf("xmpp_snprintf doesn't match Format: %s\n\txmpp_snprintf = %s\n\tsprintf = %s\n",
if (strcmp(buf1, buf2)) {
printf("xmpp_snprintf doesn't match Format: "
"%s\n\txmpp_snprintf = %s\n\tsprintf = %s\n",
int_fmt[x], buf1, buf2);
fail++;
}

15
tests/test_sock.c
View File

@@ -23,14 +23,19 @@ int wait_for_connect(sock_t sock)
fd_set wfds, efds;
int ret;
FD_ZERO(&wfds); FD_SET(sock, &wfds);
FD_ZERO(&efds); FD_SET(sock, &efds);
FD_ZERO(&wfds);
FD_SET(sock, &wfds);
FD_ZERO(&efds);
FD_SET(sock, &efds);
ret = select(sock + 1, NULL, &wfds, &efds, NULL);
if (ret <= 0) return -1;
if (ret <= 0)
return -1;
if (FD_ISSET(sock, &efds)) return 0;
if (FD_ISSET(sock, &wfds)) return 1;
if (FD_ISSET(sock, &efds))
return 0;
if (FD_ISSET(sock, &wfds))
return 1;
return -1;
}

4
tests/test_string.c
View File

@@ -75,8 +75,8 @@ static int test_strdup_one(xmpp_ctx_t *ctx, const char *s)
if (!s1 || !s2 || strcmp(s1, s2) != 0) {
rc = -1;
printf("strdup: '%s', xmpp_strdup: '%s'\n",
s1 ? s1 : "<NULL>", s2 ? s2 : "<NULL>");
printf("strdup: '%s', xmpp_strdup: '%s'\n", s1 ? s1 : "<NULL>",
s2 ? s2 : "<NULL>");
}
free(s1);