ClientTest(const QString &_host, int _port, const QString &_proto, const QString &_authzid, const QString &_realm, const QString &_user, const QString &_pass, bool _no_authzid, bool _no_realm) :
host(_host),
proto(_proto),
authzid(_authzid),
realm(_realm),
user(_user),
pass(_pass),
port(_port),
no_authzid(_no_authzid),
no_realm(_no_realm),
sock_done(false),
waitCycles(0)
{
sock = new QTcpSocket(this);
connect(sock, SIGNAL(connected()), SLOT(sock_connected()));
connect(sock, SIGNAL(readyRead()), SLOT(sock_readyRead()));
connect(sock, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(sock_error(QAbstractSocket::SocketError)));
sasl = new QCA::SASL(this);
connect(sasl, SIGNAL(clientStarted(bool, const QByteArray &)), SLOT(sasl_clientFirstStep(bool, const QByteArray &)));
connect(sasl, SIGNAL(nextStep(const QByteArray &)), SLOT(sasl_nextStep(const QByteArray &)));
connect(sasl, SIGNAL(needParams(const QCA::SASL::Params &)), SLOT(sasl_needParams(const QCA::SASL::Params &)));
connect(sasl, SIGNAL(authenticated()), SLOT(sasl_authenticated()));
connect(sasl, SIGNAL(readyRead()), SLOT(sasl_readyRead()));
connect(sasl, SIGNAL(readyReadOutgoing()), SLOT(sasl_readyReadOutgoing()));
connect(sasl, SIGNAL(error()), SLOT(sasl_error()));
}
SecureLayer(QCA::SASL *s)
{
type = SASL;
p.sasl = s;
init();
connect(p.sasl, SIGNAL(readyRead()), SLOT(sasl_readyRead()));
connect(p.sasl, SIGNAL(readyReadOutgoing()), SLOT(sasl_readyReadOutgoing()));
connect(p.sasl, SIGNAL(error()), SLOT(sasl_error()));
}
static void
pro_message_available (PROFILE_INSTANCE *pi) {
int result,
size;
char *buffer,
*payload,
*response;
FRAME *f;
struct configobj *appconfig = bp_get_config (pi -> channel -> conn);
PRO_LOCALDATA *il = (PRO_LOCALDATA *) pi -> user_ptr1;
result = SASL_ALREADY_DONE;
if (!(f = bpc_query_message (pi -> channel, BLU_QUERY_ANYTYPE,
BLU_QUERY_ANYMSG, BLU_QUERY_ANYANS)))
return;
if (pro_debug) {
fprintf (stderr,
"%s message_available: type=%c number=%ld answer=%ld size=%ld\n",
pro_name (pi -> channel -> profile_registration -> uri),
f -> msg_type, f -> message_number, f -> answer_number,
f -> size);
fprintf (stderr, f -> size > 150 ? "%-150.150s...\n" : "%s\n",
f -> payload);
fflush (stderr);
}
size = bpc_frame_aggregate (pi -> channel, f, &buffer);
if (buffer == NULL) {
bp_log (pi -> channel -> conn, LOG_PROF, 5,
"%s message_available: out of memory aggregating message",
pro_name (pi -> channel -> profile_registration -> uri));
bpc_frame_destroy (pi -> channel, f);
return;
}
switch (il -> pl_task) {
case PRO_CLIENT_ANON:
break;
case PRO_CLIENT_OTP:
if (il -> pl_sent != 2)
break;
if (strstr (buffer, "<error") != NULL)
sasl_error (pi, buffer, size);
else {
parse_blob (buffer, &il -> pl_sdb);
if (!strcmp (il -> pl_sdb.parse_blob_status, "complete"))
sasl_set_local_success (pi);
else
sasl_set_local_failure (pi, NULL);
}
break;
case PRO_SERVER_ANON:
if (il -> pl_sent != 0)
break;
if ((result = sasl_anonymous_server_guts (buffer, &il -> pl_sdb))
== SASL_COMPLETE)
config_set (appconfig, SASL_REMOTE_USERNAME,
il -> pl_sdb.parse_blob_data);
break;
case PRO_SERVER_OTP:
switch (il -> pl_sent) {
case 0:
result = sasl_otp_server_guts_1 (buffer, &il -> pl_sdb);
break;
case 1:
if ((result = sasl_otp_server_guts_2 (buffer, &il -> pl_sdb))
== SASL_COMPLETE) {
config_set (appconfig, SASL_REMOTE_USERNAME,
il -> pl_sdb.authenID);
config_set (appconfig, SASL_REMOTE_TARGET,
(il -> pl_sdb.authorID[0] != '\0')
? il -> pl_sdb.authorID
: il -> pl_sdb.authenID);
}
break;
}
break;
}
bpc_buffer_destroy (pi -> channel, buffer);
switch (il -> pl_task) {
case PRO_CLIENT_ANON:
case PRO_CLIENT_OTP:
response = NULL;
break;
case PRO_SERVER_ANON:
case PRO_SERVER_OTP:
response = sasl_response (pi, result);
break;
}
if (f -> msg_type == BLU_FRAME_TYPE_MSG) {
payload = response ? response
: "<error code='521'>Client-side only</error>";
size = strlen (payload) + sizeof DEFAULT_CONTENT_TYPE - 1;
if ((buffer = bpc_buffer_allocate(pi -> channel, size)) != NULL) {
sprintf (buffer, "%s%s", DEFAULT_CONTENT_TYPE, payload);
bpc_send (pi -> channel,
(payload[1] == 'e')
? BLU_FRAME_TYPE_ERR : BLU_FRAME_TYPE_RPY,
f -> message_number, f -> answer_number,
BLU_FRAME_COMPLETE, buffer, size);
il -> pl_sent++;
} else
bp_log (pi -> channel -> conn, LOG_PROF, 5,
"%s message: out of memory sending response",
pro_name (pi -> channel -> profile_registration -> uri));
}
bpc_frame_destroy (pi -> channel, f);
}
static void
pro_start_confirmation (void *clientData,
PROFILE_INSTANCE *pi,
PROFILE *po) {
int problem,
size;
char *buffer,
*payload;
PRO_LOCALDATA *il = clientData;
struct configobj *appconfig = bp_get_config (pi -> channel -> conn);
if (pro_debug) {
fprintf (stderr, "%s start_confirmation: piggyback=\"%s\"\n",
pro_name (po -> uri),
po -> piggyback ? po -> piggyback : "<NULL>");
fflush (stderr);
}
pi -> user_ptr1 = il;
il -> pl_flags &= ~(PRO_STARTING | PRO_CLOSED);
il -> pl_channel = pi -> channel;
if (po -> piggyback_length == 0) {
il -> pl_status = bp_diagnostic_new (pi -> channel -> conn, 504, NULL,
"expecting blob element");
return;
}
if (strstr (po -> piggyback, "<error")) {
sasl_error (pi, po -> piggyback, po -> piggyback_length);
return;
}
switch (il -> pl_task) {
case PRO_CLIENT_ANON:
parse_blob (po -> piggyback, &il -> pl_sdb);
if (!strcmp (il -> pl_sdb.parse_blob_status, "complete"))
sasl_set_local_success (pi);
else
sasl_set_local_failure (pi, NULL);
break;
case PRO_CLIENT_OTP:
if (!(payload = sasl_otp_client_guts_2
(po -> piggyback,
config_get (appconfig, SASL_LOCAL_PASSPHRASE),
&problem, &il -> pl_sdb))) {
if (problem == SASL_ERROR_ALGORITHM) {
config_set (appconfig, SASL_LOCAL_CODE, "504");
config_set (appconfig, SASL_LOCAL_REASON,
"unsupported algorithm");
} else {
config_set (appconfig, SASL_LOCAL_CODE, "501");
config_set (appconfig, SASL_LOCAL_REASON,
"unable to parse blob");
}
payload = "<blob status='abort' />";
}
size = strlen (payload) + sizeof DEFAULT_CONTENT_TYPE - 1;
if ((buffer = bpc_buffer_allocate (pi -> channel, size)) != NULL) {
sprintf (buffer, "%s%s", DEFAULT_CONTENT_TYPE, payload);
bpc_send (pi -> channel, BLU_FRAME_TYPE_MSG,
BLU_FRAME_MSGNO_UNUSED, BLU_FRAME_IGNORE_ANSNO,
BLU_FRAME_COMPLETE, buffer, size);
il -> pl_sent++;
} else
bp_log (pi -> channel -> conn, LOG_PROF, 5,
"%s start_confirmation: out of memory",
pro_name (po -> uri));
break;
}
}
