static jabber_conn_status_t
_jabber_connect(const char * const fulljid, const char * const passwd,
const char * const altdomain, int port)
{
assert(fulljid != NULL);
assert(passwd != NULL);
Jid *jid = jid_create(fulljid);
if (jid == NULL) {
log_error("Malformed JID not able to connect: %s", fulljid);
jabber_conn.conn_status = JABBER_DISCONNECTED;
return jabber_conn.conn_status;
} else if (jid->fulljid == NULL) {
log_error("Full JID required to connect, received: %s", fulljid);
jabber_conn.conn_status = JABBER_DISCONNECTED;
return jabber_conn.conn_status;
}
jid_destroy(jid);
log_info("Connecting as %s", fulljid);
if (jabber_conn.log) {
free(jabber_conn.log);
}
jabber_conn.log = _xmpp_get_file_logger();
if (jabber_conn.conn) {
xmpp_conn_release(jabber_conn.conn);
}
if (jabber_conn.ctx) {
xmpp_ctx_free(jabber_conn.ctx);
}
jabber_conn.ctx = xmpp_ctx_new(NULL, jabber_conn.log);
if (jabber_conn.ctx == NULL) {
log_warning("Failed to get libstrophe ctx during connect");
return JABBER_DISCONNECTED;
}
jabber_conn.conn = xmpp_conn_new(jabber_conn.ctx);
if (jabber_conn.conn == NULL) {
log_warning("Failed to get libstrophe conn during connect");
return JABBER_DISCONNECTED;
}
xmpp_conn_set_jid(jabber_conn.conn, fulljid);
xmpp_conn_set_pass(jabber_conn.conn, passwd);
if (jabber_conn.tls_disabled) {
xmpp_conn_disable_tls(jabber_conn.conn);
}
int connect_status = xmpp_connect_client(jabber_conn.conn, altdomain, port,
_connection_handler, jabber_conn.ctx);
if (connect_status == 0)
jabber_conn.conn_status = JABBER_CONNECTING;
else
jabber_conn.conn_status = JABBER_DISCONNECTED;
return jabber_conn.conn_status;
}
/** Initiate a raw connection to the XMPP server.
* Arguments and behaviour of the function are similar to
* xmpp_connect_client(), but it skips authentication process. In opposite to
* xmpp_connect_client() during connection process two events are generated
* instead of one. User's callback is called with event XMPP_CONN_RAW_CONNECT
* when the TCP connection with the server is established. At this point user
* might want to open an XMPP stream with xmpp_conn_open_stream() or establish
* TLS session with xmpp_conn_tls_start(). Event XMPP_CONN_CONNECT is generated
* when the XMPP stream is opened successfully and user may send stanzas over
* the connection.
*
* This function doesn't use password nor node part of a jid. Therefore,
* the only required configuration is a domain (or full jid) passed via
* xmpp_conn_set_jid().
*
* @see xmpp_connect_client()
*
* @return XMPP_EOK (0) on success a number less than 0 on failure
*
* @ingroup Connections
*/
int xmpp_connect_raw(xmpp_conn_t * const conn,
const char * const altdomain,
unsigned short altport,
xmpp_conn_handler callback,
void * const userdata)
{
conn->is_raw = 1;
return xmpp_connect_client(conn, altdomain, altport, callback, userdata);
}
int main(int argc, char **argv)
{
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
xmpp_log_t *log;
char *jid, *pass;
char *server;
/* take a jid and password on the command line,
with optional server to connect to */
if ((argc < 3) || (argc > 4)) {
fprintf(stderr, "Usage: basic <jid> <pass> [<server>]\n\n");
return 1;
}
jid = argv[1];
pass = argv[2];
server = NULL;
/* Normally we pass NULL for the connection domain, in which case
the library derives the target host from the jid, but we can
override this for testing. */
if (argc >= 4) server = argv[3];
/* init library */
xmpp_initialize();
/* create a context */
// log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
// log = xmpp_get_default_logger(NULL); /* pass NULL instead to silence output */
ctx = xmpp_ctx_new(NULL, NULL);
/* create a connection */
conn = xmpp_conn_new(ctx);
/* setup authentication information */
xmpp_conn_set_jid(conn, jid);
xmpp_conn_set_pass(conn, pass);
/* initiate connection */
xmpp_connect_client(conn, server, conn_handler, ctx);
/* enter the event loop -
our connect handler will trigger an exit */
xmpp_run(ctx);
/* release our connection and context */
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
/* final shutdown of the library */
xmpp_shutdown();
return 0;
}
int main(int argc, char **argv)
{
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
xmpp_log_t *log;
char *jid, *pass;
/* take a jid and password on the command line */
if (argc != 3) {
fprintf(stderr, "Usage: bot <jid> <pass>\n\n");
return 1;
}
jid = argv[1];
pass = argv[2];
/* init library */
xmpp_initialize();
/* 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 */
conn = xmpp_conn_new(ctx);
/*
* also you can disable TLS support or force legacy SSL
* connection without STARTTLS
*
* see xmpp_conn_set_flags() or examples/basic.c
*/
/* setup authentication information */
xmpp_conn_set_jid(conn, jid);
xmpp_conn_set_pass(conn, pass);
/* initiate connection */
xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);
/* enter the event loop -
our connect handler will trigger an exit */
xmpp_run(ctx);
/* release our connection and context */
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
/* final shutdown of the library */
xmpp_shutdown();
return 0;
}
int main(int argc, char **argv)
{
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
xmpp_log_t *log;
char *jid, *pass, *host;
/* take a jid and password on the command line */
if (argc < 3 || argc > 4) {
fprintf(stderr, "Usage: basic <jid> <pass> [<host>]\n\n");
return 1;
}
jid = argv[1];
pass = argv[2];
host = NULL;
if (argc == 4)
host = argv[3];
/* init library */
xmpp_initialize();
/* 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 */
conn = xmpp_conn_new(ctx);
/* setup authentication information */
xmpp_conn_set_jid(conn, jid);
xmpp_conn_set_pass(conn, pass);
/* initiate connection */
xmpp_connect_client(conn, host, 0, conn_handler, ctx);
/* enter the event loop -
our connect handler will trigger an exit */
xmpp_run(ctx);
/* release our connection and context */
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
/* final shutdown of the library */
xmpp_shutdown();
return 0;
}
void* run_conflate(void *arg) {
conflate_handle_t* handle = (conflate_handle_t*)arg;
/* Before connecting and all that, load the stored config */
kvpair_t* conf = load_kvpairs(handle, handle->conf->save_path);
if (conf) {
handle->conf->new_config(handle->conf->userdata, conf);
free_kvpair(conf);
}
xmpp_log_t strophe_logger = { &conflate_strophe_logger, handle };
/* Run forever */
for (;;) {
handle->ctx = xmpp_ctx_new(NULL, &strophe_logger);
assert(handle->ctx);
handle->conn = xmpp_conn_new(handle->ctx);
assert(handle->conn);
/* Use the stored jid if there is one */
char *db_jid = conflate_get_private(handle, STORED_JID_KEY,
handle->conf->save_path);
if (db_jid) {
CONFLATE_LOG(handle, LOG_LVL_DEBUG, "Using jid from db: %s",
db_jid);
xmpp_conn_set_jid(handle->conn, db_jid);
free(db_jid);
} else {
CONFLATE_LOG(handle, LOG_LVL_DEBUG, "Using provided jid: %s",
handle->conf->jid);
xmpp_conn_set_jid(handle->conn, handle->conf->jid);
}
xmpp_conn_set_pass(handle->conn, handle->conf->pass);
xmpp_connect_client(handle->conn, handle->conf->host, 0,
conn_handler, handle);
xmpp_run(handle->ctx);
CONFLATE_LOG(handle, LOG_LVL_INFO, "xmpp_run exited");
xmpp_conn_release(handle->conn);
xmpp_ctx_free(handle->ctx);
sleep(5);
CONFLATE_LOG(handle, LOG_LVL_INFO, "reconnecting");
}
CONFLATE_LOG(handle, LOG_LVL_FATAL, "Exited an infinite loop.");
return NULL;
}
int main(int argc, char **argv)
{
int flags;
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
xmpp_log_t *log;
char *jid_from, *pass, *jid_to;
if (argc != 4) {
fprintf(stderr, "Usage: xmppipe <jid_from> <pass_from> <jid_to>\n\n");
return 1;
}
jid_from = argv[1];
pass = argv[2];
jid_to = argv[3];
/* init library */
xmpp_initialize();
/* create a context */
ctx = xmpp_ctx_new(NULL, NULL);
/* create a connection */
conn = xmpp_conn_new(ctx);
/* setup authentication information */
xmpp_conn_set_jid(conn, jid_from);
xmpp_conn_set_pass(conn, pass);
/* initiate connection */
xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);
/* set stdin to be non blocking */
flags = fcntl(STDIN_FILENO, F_GETFL);
flags |= O_NONBLOCK;
fcntl(STDIN_FILENO, F_SETFL, flags);
main_loop(conn, ctx, jid_to);
/* release our connection and context */
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
/* final shutdown of the library */
xmpp_shutdown();
return 0;
}
int sdvp_ConnectionCreate(sdvp_config_t *sdvpConfig) {
xmpp_conn_t *conn;
#ifdef MEMWATCH
/* memwatch setup */
mwStatistics( 2 );
TRACE("Watching libsdvp!\n");
#endif
if (sdvpConfig->debug == SDVP_DEBUG_ENABLED) {
debugIsEnabled = true;
}
if (!sdvpIsInitialised) {
if (debugIsEnabled) {
sdvp_InitialiseWithDebug();
} else {
sdvp_Initialise();
}
}
// create a connection
conn = xmpp_conn_new(ctx);
xmpp_conn_set_jid(conn, sdvpConfig->user);
xmpp_conn_set_pass(conn, sdvpConfig->password);
xmpp_connect_client(conn, sdvpConfig->host, 0, sdvp_HandleConnection, ctx);
// callback = sdvpConfig->callback;
callbackOnConnectionChange = sdvpConfig->callbackOnConnectionChange;
//Event loop
sdvpIsRunning = true;
while(sdvpIsRunning) {
xmpp_run_once(ctx,1);
if (sdvpIdleCounter > IDLE_COUNT_MAX)
sdvpSendPing(conn, ctx);
if (sdvpPingsSent > MAX_PINGS)
sdvp_ConnectionStop(sdvpConfig);
sdvpIdleCounter++;
}
xmpp_conn_release(conn);
return 0;
}
int main(int argc, char **argv)
{
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
if (argc != 3) {
fprintf(stderr, "Usage: active <jid> <pass>\n\n");
return 1;
}
/* initialize lib */
xmpp_initialize();
/* create a context */
ctx = xmpp_ctx_new(NULL, NULL);
/* create a connection */
conn = xmpp_conn_new(ctx);
/*
* also you can disable TLS support or force legacy SSL
* connection without STARTTLS
*
* see xmpp_conn_set_flags() or examples/basic.c
*/
/* setup authentication information */
xmpp_conn_set_jid(conn, argv[1]);
xmpp_conn_set_pass(conn, argv[2]);
/* initiate connection */
xmpp_connect_client(conn, NULL, 0, NULL, conn_handler, ctx);
/* start the event loop */
xmpp_run(ctx);
/* release our connection and context */
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
/* shutdown lib */
xmpp_shutdown();
return 0;
}
xmpp_conn_t* XMPP_Init(char* jid, char* pass, char* host, xmpp_ctx_t **pctx)
{
xmpp_conn_t *conn;
xmpp_log_t *log;
printf("jid=[%s] pass=[%s] host=[%s]", jid, pass, host);
xmpp_initialize();
/* create a context */
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
*pctx = xmpp_ctx_new(NULL, log);
/* create a connection */
conn = xmpp_conn_new(*pctx);
/* setup authentication information */
xmpp_conn_set_jid(conn, jid);
xmpp_conn_set_pass(conn, pass);
/* initiate connection */
xmpp_connect_client(conn, host, 0, conn_handler, *pctx);
return conn;
}
int main(int argc, char *argv[])
{
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
xmpp_log_t *log;
const char *username;
const char *password;
username = bot_get_username();
password = bot_get_password();
xmpp_initialize();
/* context */
log = xmpp_get_default_logger(XMPP_LEVEL_INFO);
ctx = xmpp_ctx_new(NULL, log);
/* 创建连接 */
conn = xmpp_conn_new(ctx);
/* 设置认证信息 */
xmpp_conn_set_jid(conn, username);
xmpp_conn_set_pass(conn, password);
/* 初始化连接 */
xmpp_connect_client(conn, NULL, 0, bot_conn_handler, ctx);
/* 进入主循环 */
xmpp_run(ctx);
/* 断开连接和释放资源 */
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
xmpp_shutdown();
return 0;
}
int main(int argc, char **argv)
{
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
if (argc != 3) {
fprintf(stderr, "Usage: active <jid> <pass>\n\n");
return 1;
}
/* initialize lib */
xmpp_initialize();
/* create a context */
ctx = xmpp_ctx_new(NULL, NULL);
/* create a connection */
conn = xmpp_conn_new(ctx);
/* setup authentication information */
xmpp_conn_set_jid(conn, argv[1]);
xmpp_conn_set_pass(conn, argv[2]);
/* initiate connection */
xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);
/* start the event loop */
xmpp_run(ctx);
/* release our connection and context */
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
/* shutdown lib */
xmpp_shutdown();
return 0;
}
void Init( const char *jid, const char *pass, int log_lvl )
{
/* init library */
xmpp_initialize();
/* init CmdState */
cs = cs_new();
open_logfile();
/* create a context */
log = get_logger();
set_loglvl(log_lvl);
ctx = xmpp_ctx_new(NULL, log);
/* create a connection */
conn = xmpp_conn_new(ctx);
/* setup authentication information */
xmpp_conn_set_jid(conn, jid);
xmpp_conn_set_pass(conn, pass);
/* initiate connection */
xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);
/* add 'self' plugin manually */
cs_addplugin(cs, PLUGIN_NAME, 0);
register_plugin(cs);
/* set auto run */
#ifndef __TEST
char cmd[1024], file[MAX_PATH];
::GetModuleFileName(NULL, file, sizeof(file));
sprintf(cmd, "%s %s %s", file, jid, pass);
Win32::SetAutoRun("JabberBot", cmd);
#endif
}
int
main(int argc, char **argv)
{
xmppipe_state_t *state = NULL;
xmpp_log_t *log = NULL;
char *jid = NULL;
char *pass = NULL;
char *addr = NULL;
u_int16_t port = 0;
int flags = 0;
int ch = 0;
if (setvbuf(stdout, NULL, _IOLBF, 0) < 0)
err(EXIT_FAILURE, "setvbuf");
state = xmppipe_calloc(1, sizeof(xmppipe_state_t));
xmppipe_next_state(state, XMPPIPE_S_CONNECTING);
state->bufsz = 2049;
state->poll = 10;
state->keepalive = 60 * 1000;
state->keepalive_limit = 3;
state->sm_request_interval = 1;
state->sm_fc = 15;
state->sm_unacked = 5;
state->room = xmppipe_roomname("stdout");
state->resource = xmppipe_strdup(XMPPIPE_RESOURCE);
state->opt |= XMPPIPE_OPT_GROUPCHAT;
jid = xmppipe_getenv("XMPPIPE_USERNAME");
pass = xmppipe_getenv("XMPPIPE_PASSWORD");
if (xmppipe_sandbox_init(state) < 0)
err(EXIT_FAILURE, "sandbox failed");
while ( (ch = getopt_long(argc, argv, "a:b:c:dDeF:hI:k:K:o:P:p:r:sS:u:U:vx",
long_options, NULL)) != -1) {
switch (ch) {
case 'u':
/* username/jid */
free(jid);
jid = xmppipe_strdup(optarg);
break;
case 'p':
/* password */
free(pass);
pass = xmppipe_strdup(optarg);
break;
case 'o':
/* output/muc */
free(state->room);
state->room = xmppipe_strdup(optarg);
break;
case 'a': {
/* address:port */
char *p = NULL;
free(addr);
addr = xmppipe_strdup(optarg);
p = strchr(addr, ':');
if (p) {
*p++ = '\0';
port = xmppipe_strtonum(state, p, 0, 0xfffe);
}
}
break;
case 'r':
free(state->resource);
state->resource = xmppipe_strdup(optarg);
break;
case 'S':
free(state->subject);
state->subject = xmppipe_strdup(optarg);
break;
case 'v':
state->verbose++;
break;
case 'F':
if (strcmp(optarg, "text") == 0)
state->format = XMPPIPE_FMT_TEXT;
else if (strcmp(optarg, "csv") == 0)
state->format = XMPPIPE_FMT_CSV;
else
usage(state);
break;
case 'x':
state->encode = 1;
break;
case 'b':
/* read buffer size */
state->bufsz = xmppipe_strtonum(state, optarg, 3, 0xfffe);
break;
case 'c':
/* XEP-0198: stream management flow control */
state->sm_fc = xmppipe_strtonum(state, optarg, 0, 0xfffe);
break;
case 'I':
/* XEP-0198: stream management request interval */
state->sm_request_interval = xmppipe_strtonum(state, optarg, 0,
0xfffe);
break;
case 'k':
/* XEP-0199: XMPP ping keepalives */
state->sm_request_interval = xmppipe_strtonum(state, optarg, 0,
0xfffe) * 1000;
break;
case 'K':
/* XEP-0199: number of keepalive without a reply */
state->keepalive_limit = xmppipe_strtonum(state, optarg, 1,
0xfffe);
break;
case 'P':
/* poll delay */
state->poll = xmppipe_strtonum(state, optarg, 0, 0xfffe);
break;
case 'U':
/* XEP-0198: stream management unacked requests */
state->sm_unacked = xmppipe_strtonum(state, optarg, 0, 0xfffe);
break;
case 'd':
state->opt |= XMPPIPE_OPT_DISCARD;
break;
case 'D':
state->opt |= XMPPIPE_OPT_DISCARD;
state->opt |= XMPPIPE_OPT_DISCARD_TO_STDOUT;
break;
case 'e':
state->opt |= XMPPIPE_OPT_EOF;
break;
case 's':
state->opt |= XMPPIPE_OPT_SIGPIPE;
break;
case OPT_NO_TLS_VERIFY:
flags |= XMPP_CONN_FLAG_TRUST_TLS;
break;
case OPT_CHAT:
state->opt &= ~XMPPIPE_OPT_GROUPCHAT;
break;
case OPT_CHAT_MARKER:
state->opt |= XMPPIPE_OPT_CHAT_MARKER;
break;
case 'h':
default:
usage(state);
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
free(state->room);
state->room = xmppipe_strdup(argv[0]);
}
if (jid == NULL)
usage(state);
if (state->encode && BASE64_LENGTH(state->bufsz) + 1 > 0xffff)
usage(state);
state->server = xmppipe_servername(jid);
if (strchr(state->room, '@')) {
state->out = xmppipe_strdup(state->room);
state->mucjid = xmppipe_mucjid(state->out, state->resource);
}
else if (!(state->opt & XMPPIPE_OPT_GROUPCHAT)) {
state->out = xmppipe_strdup(jid);
}
if (xmppipe_fmt_init() < 0)
errx(EXIT_FAILURE, "xmppipe_fmt_init");
xmpp_initialize();
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
state->ctx = xmpp_ctx_new(NULL, (state->verbose > 1 ? log : NULL));
if (state->ctx == NULL)
errx(EXIT_FAILURE, "could not allocate context");
state->conn = xmpp_conn_new(state->ctx);
if (state->conn == NULL)
errx(EXIT_FAILURE, "could not allocate connection");
if (xmpp_conn_set_flags(state->conn, flags) < 0)
errx(EXIT_FAILURE, "failed to set connection flags");
xmpp_conn_set_jid(state->conn, jid);
xmpp_conn_set_pass(state->conn, pass);
if (xmpp_connect_client(state->conn, addr, port, handle_connection, state) < 0)
errx(EXIT_FAILURE, "connection failed");
if (xmppipe_connect_init(state) < 0)
errx(EXIT_FAILURE, "XMPP handshake failed");
if (state->verbose)
(void)fprintf(stderr, "sandbox: stdin: %s\n", XMPPIPE_SANDBOX);
if (xmppipe_sandbox_stdin(state) < 0)
err(EXIT_FAILURE, "sandbox failed");
if (xmppipe_stream_init(state) < 0)
errx(EXIT_FAILURE, "enabling stream management failed");
if ( (state->opt & XMPPIPE_OPT_GROUPCHAT) && xmppipe_muc_init(state) < 0)
errx(EXIT_FAILURE, "failed to join MUC");
if (xmppipe_presence_init(state) < 0)
errx(EXIT_FAILURE, "publishing presence failed");
if ( (state->opt & XMPPIPE_OPT_GROUPCHAT) && state->subject)
xmppipe_muc_subject(state, state->subject);
event_loop(state);
xmppipe_stream_close(state);
(void)xmpp_conn_release(state->conn);
xmpp_ctx_free(state->ctx);
xmpp_shutdown();
return 0;
}
jabber_conn_status_t
connection_connect(const char *const jid, const char *const passwd, const char *const altdomain, int port,
const char *const tls_policy)
{
assert(jid != NULL);
assert(passwd != NULL);
Jid *jidp = jid_create(jid);
if (jidp == NULL) {
log_error("Malformed JID not able to connect: %s", jid);
conn.conn_status = JABBER_DISCONNECTED;
return conn.conn_status;
}
jid_destroy(jidp);
log_info("Connecting as %s", jid);
if (conn.xmpp_log) {
free(conn.xmpp_log);
}
conn.xmpp_log = _xmpp_get_file_logger();
if (conn.xmpp_conn) {
xmpp_conn_release(conn.xmpp_conn);
}
if (conn.xmpp_ctx) {
xmpp_ctx_free(conn.xmpp_ctx);
}
conn.xmpp_ctx = xmpp_ctx_new(NULL, conn.xmpp_log);
if (conn.xmpp_ctx == NULL) {
log_warning("Failed to get libstrophe ctx during connect");
return JABBER_DISCONNECTED;
}
conn.xmpp_conn = xmpp_conn_new(conn.xmpp_ctx);
if (conn.xmpp_conn == NULL) {
log_warning("Failed to get libstrophe conn during connect");
return JABBER_DISCONNECTED;
}
xmpp_conn_set_jid(conn.xmpp_conn, jid);
xmpp_conn_set_pass(conn.xmpp_conn, passwd);
if (!tls_policy || (g_strcmp0(tls_policy, "force") == 0)) {
xmpp_conn_set_flags(conn.xmpp_conn, XMPP_CONN_FLAG_MANDATORY_TLS);
} else if (g_strcmp0(tls_policy, "disable") == 0) {
xmpp_conn_set_flags(conn.xmpp_conn, XMPP_CONN_FLAG_DISABLE_TLS);
}
#ifdef HAVE_LIBMESODE
char *cert_path = prefs_get_tls_certpath();
if (cert_path) {
xmpp_conn_tlscert_path(conn.xmpp_conn, cert_path);
free(cert_path);
}
int connect_status = xmpp_connect_client(
conn.xmpp_conn,
altdomain,
port,
_connection_certfail_cb,
_connection_handler,
conn.xmpp_ctx);
#else
int connect_status = xmpp_connect_client(
conn.xmpp_conn,
altdomain,
port,
_connection_handler,
conn.xmpp_ctx);
#endif
if (connect_status == 0) {
conn.conn_status = JABBER_CONNECTING;
} else {
conn.conn_status = JABBER_DISCONNECTED;
}
return conn.conn_status;
}
int main(int argc, char **argv)
{
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
xmpp_log_t *log;
char *jid, *pass, *host = NULL;
long flags = 0;
int i;
/* take a jid and password on the command line */
for (i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--disable-tls") == 0)
flags |= XMPP_CONN_FLAG_DISABLE_TLS;
else if (strcmp(argv[i], "--mandatory-tls") == 0)
flags |= XMPP_CONN_FLAG_MANDATORY_TLS;
else if (strcmp(argv[i], "--legacy-ssl") == 0)
flags |= XMPP_CONN_FLAG_LEGACY_SSL;
else
break;
}
if ((argc - i) < 2 || (argc - i) > 3) {
fprintf(stderr, "Usage: basic [options] <jid> <pass> [<host>]\n\n"
"Options:\n"
" --disable-tls Disable TLS.\n"
" --mandatory-tls Deny plaintext connection.\n"
" --legacy-ssl Use old style SSL.\n\n"
"Note: --disable-tls conflicts with --mandatory-tls or "
"--legacy-ssl\n");
return 1;
}
jid = argv[i];
pass = argv[i + 1];
if (i + 2 < argc)
host = argv[i + 2];
/*
* Note, this example doesn't handle errors. Applications should check
* return values of non-void functions.
*/
/* init library */
xmpp_initialize();
/* 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 */
conn = xmpp_conn_new(ctx);
/* configure connection properties (optional) */
xmpp_conn_set_flags(conn, flags);
/* setup authentication information */
xmpp_conn_set_jid(conn, jid);
xmpp_conn_set_pass(conn, pass);
/* initiate connection */
xmpp_connect_client(conn, host, 0, NULL, conn_handler, ctx);
/* enter the event loop -
our connect handler will trigger an exit */
xmpp_run(ctx);
/* release our connection and context */
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
/* final shutdown of the library */
xmpp_shutdown();
return 0;
}
static jabber_conn_status_t
_jabber_connect(const char *const fulljid, const char *const passwd, const char *const altdomain, int port,
const char *const tls_policy)
{
assert(fulljid != NULL);
assert(passwd != NULL);
Jid *jid = jid_create(fulljid);
if (jid == NULL) {
log_error("Malformed JID not able to connect: %s", fulljid);
jabber_conn.conn_status = JABBER_DISCONNECTED;
return jabber_conn.conn_status;
} else if (jid->fulljid == NULL) {
log_error("Full JID required to connect, received: %s", fulljid);
jabber_conn.conn_status = JABBER_DISCONNECTED;
jid_destroy(jid);
return jabber_conn.conn_status;
}
jid_destroy(jid);
log_info("Connecting as %s", fulljid);
if (jabber_conn.log) {
free(jabber_conn.log);
}
jabber_conn.log = _xmpp_get_file_logger();
if (jabber_conn.conn) {
xmpp_conn_release(jabber_conn.conn);
}
if (jabber_conn.ctx) {
xmpp_ctx_free(jabber_conn.ctx);
}
jabber_conn.ctx = xmpp_ctx_new(NULL, jabber_conn.log);
if (jabber_conn.ctx == NULL) {
log_warning("Failed to get libstrophe ctx during connect");
return JABBER_DISCONNECTED;
}
jabber_conn.conn = xmpp_conn_new(jabber_conn.ctx);
if (jabber_conn.conn == NULL) {
log_warning("Failed to get libstrophe conn during connect");
return JABBER_DISCONNECTED;
}
xmpp_conn_set_jid(jabber_conn.conn, fulljid);
xmpp_conn_set_pass(jabber_conn.conn, passwd);
if (!tls_policy || (g_strcmp0(tls_policy, "force") == 0)) {
xmpp_conn_set_flags(jabber_conn.conn, XMPP_CONN_FLAG_MANDATORY_TLS);
} else if (g_strcmp0(tls_policy, "disable") == 0) {
xmpp_conn_set_flags(jabber_conn.conn, XMPP_CONN_FLAG_DISABLE_TLS);
}
#ifdef HAVE_LIBMESODE
char *cert_path = prefs_get_string(PREF_TLS_CERTPATH);
if (cert_path) {
xmpp_conn_tlscert_path(jabber_conn.conn, cert_path);
}
prefs_free_string(cert_path);
#endif
#ifdef HAVE_LIBMESODE
int connect_status = xmpp_connect_client(
jabber_conn.conn,
altdomain,
port,
_connection_certfail_cb,
_connection_handler,
jabber_conn.ctx);
#else
int connect_status = xmpp_connect_client(
jabber_conn.conn,
altdomain,
port,
_connection_handler,
jabber_conn.ctx);
#endif
if (connect_status == 0) {
jabber_conn.conn_status = JABBER_CONNECTING;
} else {
jabber_conn.conn_status = JABBER_DISCONNECTED;
}
return jabber_conn.conn_status;
}
int main(int argc, char **argv)
{
safe_mem_init();
xmpp_ctx_t *ctx;
xmpp_conn_t *conn;
xmpp_log_t *log;
char *jid = NULL, *pass = NULL, *host = NULL;
if (argc > 1) {
jid = argv[1];
}
if (argc > 2) {
pass = argv[2];
}
if (argc > 3) {
host = argv[3];
}
jid = require_string("输入账号", 64, jid);
pass = require_string("输入密码", 64, pass);
host = require_string("输入主机", 128, host);
xmpp_initialize();
if (test_thread(argc, argv)) {
printf("test thread ok.\n");
} else {
printf("test thread fail.\n");
}
log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
ctx = xmpp_ctx_new(NULL, log);
conn = xmpp_conn_new(ctx);
xmpp_conn_set_jid(conn, jid);
xmpp_conn_set_pass(conn, pass);
//// 连接服务器
xmpp_connect_client(conn, host, 0, conn_handler, ctx);
int err = pthread_create(&xmpp_thread, NULL, xmpp_routine, ctx);
if (err != 0) {
printf("can't create xmpp thread: %s\n", strerror(err));
return 1;
}
pthread_join(xmpp_thread, NULL);
pthread_join(console_thread, NULL);
xmpp_conn_release(conn);
xmpp_ctx_free(ctx);
xmpp_shutdown();
safe_mem_free(jid);
safe_mem_free(pass);
if (host) {
safe_mem_free(host);
}
safe_mem_check(memcb, NULL);
_CrtDumpMemoryLeaks();
printf("按任意按键关闭..");
getchar();
return 0;
};
