static void purple_login( account_t *acc ) { struct im_connection *ic = imcb_new( acc ); PurpleAccount *pa; if( ( local_bee != NULL && local_bee != acc->bee ) || ( global.conf->runmode == RUNMODE_DAEMON && !getenv( "BITLBEE_DEBUG" ) ) ) { imcb_error( ic, "Daemon mode detected. Do *not* try to use libpurple in daemon mode! " "Please use inetd or ForkDaemon mode instead." ); imc_logout( ic, FALSE ); return; } local_bee = acc->bee; /* For now this is needed in the _connected() handlers if using GLib event handling, to make sure we're not handling events on dead connections. */ purple_connections = g_slist_prepend( purple_connections, ic ); ic->proto_data = pa = purple_account_new( acc->user, (char*) acc->prpl->data ); purple_account_set_password( pa, acc->pass ); purple_sync_settings( acc, pa ); purple_account_set_enabled( pa, "BitlBee", TRUE ); }
int main(int argc, char *argv[]) { GMainLoop *loop = g_main_loop_new(NULL, FALSE); /* libpurple's built-in DNS resolution forks processes to perform * blocking lookups without blocking the main process. It does not * handle SIGCHLD itself, so if the UI does not you quickly get an army * of zombie subprocesses marching around. */ signal(SIGCHLD, SIG_IGN); init_libpurple(); printf("libpurple initialized. Running version %s.\n", purple_core_get_version()); //I like to see the version number connect_to_signals(); PurpleAccount *account = purple_account_new(PACCOUNT_NAME, "prpl-aim"); //this could be prpl-aim, prpl-yahoo, prpl-msn, prpl-icq, etc. purple_account_set_password(account, PACCOUNT_PASS); purple_accounts_add(account); purple_account_set_enabled(account, UI_ID, TRUE); g_main_loop_run(loop); return 0; }
static void purple_login(account_t *acc) { struct im_connection *ic = imcb_new(acc); struct purple_data *pd; if ((local_bee != NULL && local_bee != acc->bee) || (global.conf->runmode == RUNMODE_DAEMON && !getenv("BITLBEE_DEBUG"))) { imcb_error(ic, "Daemon mode detected. Do *not* try to use libpurple in daemon mode! " "Please use inetd or ForkDaemon mode instead."); imc_logout(ic, FALSE); return; } local_bee = acc->bee; /* For now this is needed in the _connected() handlers if using GLib event handling, to make sure we're not handling events on dead connections. */ purple_connections = g_slist_prepend(purple_connections, ic); ic->proto_data = pd = g_new0(struct purple_data, 1); pd->account = purple_account_new(acc->user, (char *) acc->prpl->data); pd->input_requests = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free); pd->next_request_id = 0; purple_account_set_password(pd->account, acc->pass); purple_sync_settings(acc, pd->account); purple_account_set_enabled(pd->account, "BitlBee", TRUE); if (set_getbool(&acc->set, "mail_notifications") && set_getstr(&acc->set, "mail_notifications_handle")) { imcb_add_buddy(ic, set_getstr(&acc->set, "mail_notifications_handle"), NULL); } }
int main(int argc, char *argv[]) { if(argc < 4) { printf("Usage: %s [Gtalk username] [password] [recipient address] [message]\n", argv[0]); return 1; } input_address = argv[3]; input_message = argv[4]; GMainLoop *loop = g_main_loop_new(NULL, FALSE); /* libpurple's built-in DNS resolution forks processes to perform * blocking lookups without blocking the main process. It does not * handle SIGCHLD itself, so if the UI does not you quickly get an army * of zombie subprocesses marching around. */ signal(SIGCHLD, SIG_IGN); init_libpurple(); connect_to_signals(); PurpleAccount *account = purple_account_new(argv[1], "prpl-jabber"); purple_account_set_password(account, argv[2]); purple_accounts_add(account); purple_account_set_enabled(account, UI_ID, TRUE); g_main_loop_run(loop); return 0; }
PurpleAccount *mimoc_account_new(char *name, char *protocoll, _Bool enabled) { PurpleAccount *account = purple_account_new(name, protocoll); purple_accounts_add(account); purple_account_set_enabled(account, UI_ID, enabled); return account; }
static void setup_integration (void) { init_libpurple(); PurpleAccount* prpl_account = purple_account_new("test_user", "yammer"); purple_account_set_enabled(prpl_account, "test_runner", TRUE); account = yammer_account_new(prpl_account); }
PurpleAccount* createPurpleAccount(MojString username, MojString prpl, MojObject prefs) { PurplePluginProtocolInfo* info = getProtocolInfo(prpl.data()); // TODO: Strip off possible junk here! // The Username Split API might be useful, as soon as I have // understood it ... PurpleAccount* account = purple_account_new(username.data(), prpl.data()); for(GList* l = info->protocol_options; l != NULL; l = l->next) { PurpleAccountOption* option = (PurpleAccountOption*)l->data; const char* name = purple_account_option_get_setting(option); if (!prefs.contains(name)) continue; switch(purple_account_option_get_type(option)) { case PURPLE_PREF_BOOLEAN: { bool value; prefs.get(name, value); purple_account_set_bool(account, name, value); } break; case PURPLE_PREF_INT: { bool found; int value; prefs.get(name, value, found); purple_account_set_int(account, name, value); } break; case PURPLE_PREF_STRING: case PURPLE_PREF_STRING_LIST: { bool found; MojString value; prefs.get(name, value, found); purple_account_set_string(account, name, value.data()); } break; default: continue; } } return account; }
QuetzalAccount::QuetzalAccount(const QString &id, QuetzalProtocol *protocol) : Account(id, protocol) { Q_ASSERT(!"Shouldn't use this constructor"); m_isLoading = false; Config cfg = config(); QString purpleId = id; if (protocol->id() == QLatin1String("irc")) { purpleId = cfg.value(QLatin1String("nicks"), QStringList()).value(0); purpleId += QLatin1Char('@'); int size = cfg.beginArray("servers"); if (size == 0) { qCritical("Invalid irc account without server info: \"%s\"", qPrintable(id)); deleteLater(); return; } cfg.setArrayIndex(0); purpleId += cfg.value(QLatin1String("hostName"), QString()); cfg.endArray(); } m_account = purple_account_new(purpleId.toUtf8(), protocol->plugin()->info->id); m_account->ui_data = this; fillStatusActions(); setContactsFactory(new QuetzalContactsFactory(this)); // if (PURPLE_PLUGIN_PROTOCOL_INFO(m_account->gc->prpl)->chat_info != NULL) { // addAction((new ActionGenerator(QIcon(), QT_TRANSLATE_NOOP("Quetzal", "Join groupchat"), this, SLOT(showJoinGroupChat())))->setType(1)); // } debug() << "created!" << this << m_account->protocol_id; // Hack for anti-auto-connect for (GList *it = purple_presence_get_statuses(m_account->presence); it; it = it->next) { PurpleStatus *status = reinterpret_cast<PurpleStatus *>(it->data); // debug() << purple_status_type_get_primitive(purple_status_get_type(status)) // << !!purple_status_is_online(status) // << purple_status_get_id(status) // << purple_status_get_name(status); if (!purple_status_is_online(status)) { purple_presence_set_status_active(m_account->presence, purple_status_get_id(status), TRUE); break; } } m_isLoading = true; load(cfg); m_isLoading = false; // if (protocol->id() == "jabber" && id.contains("qutim.org")) { if (!purple_account_get_enabled(m_account, "qutim")) purple_account_set_enabled(m_account, "qutim", TRUE); // purple_account_connect(m_account); // } else // purple_account_set_enabled(m_account, "qutim", FALSE); }
static VALUE login(VALUE self, VALUE protocol, VALUE username, VALUE password) { PurpleAccount* account = purple_account_new(RSTRING_PTR(username), RSTRING_PTR(protocol)); if (NULL == account || NULL == account->presence) { rb_raise(rb_eRuntimeError, "No able to create account: %s", RSTRING_PTR(protocol)); } purple_account_set_password(account, RSTRING_PTR(password)); purple_account_set_remember_password(account, TRUE); purple_account_set_enabled(account, UI_ID, TRUE); PurpleSavedStatus *status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE); purple_savedstatus_activate(status); purple_accounts_add(account); return Data_Wrap_Struct(cAccount, NULL, NULL, account); }
/* {{{ Methods */ static int account_new(LuaState *L)/*{{{*/ { luaL_checktype(L, 1, LUA_TTABLE); const char *username = luaL_checkstring(L, 2); const char *proto_id = luaL_checkstring(L, 3); PurpleAccount **account = ms_lua_newclass(L, "purple.account", sizeof(PurpleAccount *)); *account = purple_account_new(username, proto_id); lua_pushlightuserdata(L, *account); lua_pushvalue(L, -2); lua_settable(L, LUA_REGISTRYINDEX); purple_accounts_add(*account); return 1; }/*}}}*/
void AccountWindow::addAccount(CppConsUI::Button& /*activator*/) { GList *i = purple_plugins_get_protocols(); PurpleAccount *account = purple_account_new(_("Username"), purple_plugin_get_id(reinterpret_cast<PurplePlugin*>(i->data))); /* Stop here if libpurple returned an already created account. This happens * when user pressed Add button twice in a row. In that case there is * already one "empty" account that user can edit. */ if (account_entries.find(account) == account_entries.end()) { purple_accounts_add(account); populateAccount(account); } account_entries[account].parent->grabFocus(); }
PurpleAccount *client_find_account(extern_account_t *account) { PurpleAccount *r; char* plugin; char username[255]; memset(username, 0, 255); if (strcmp(account->protocol, "gtalk") == 0) { sprintf(username, "%s%s", account->username, "/sip"); plugin = "prpl-jabber"; } else { sprintf(username, "%s", account->username); plugin = account->protocol; } LM_DBG("searching purple account for %s with plugin %s \n", username, plugin); r = purple_accounts_find(username, plugin); if (r) { LM_DBG("account %s found\n", username); return r; } LM_DBG("account %s not found, creating.\n", username); r = purple_account_new(username, plugin); purple_account_set_password(r, account->password); purple_account_set_remember_password(r, TRUE); if (proxy != NULL) purple_account_set_proxy_info(r, proxy); if (strcmp(account->protocol, "gtalk") == 0) purple_account_set_string(r, "connect_server", "talk.google.com"); purple_accounts_add(r); return r; }
void IMInvoker::invoke(void *userdata, const std::string event) { _accountMutex.lock(); EventContext* ctx = (EventContext*)userdata; IMInvoker* instance = ctx->instance; std::string username; Event::getParam(ctx->invokeReq.params, "username", username); std::string protocolId; Event::getParam(ctx->invokeReq.params, "protocol", protocolId); std::string password; Event::getParam(ctx->invokeReq.params, "password", password); instance->_account = purple_account_new(username.c_str(), protocolId.c_str()); _accountInstances[instance->_account] = instance; #if LIBPURPLE_VERSION_MAJOR >= 3 purple_account_set_password(instance->_account, password.c_str(), NULL, NULL); #else purple_account_set_password(instance->_account, password.c_str()); #endif purple_account_set_enabled(instance->_account, "uscxml", true); GSList* buddies = purple_blist_get_buddies(); GSList *cur; for (cur = buddies; cur; cur = cur->next) { std::string buddyName = purple_buddy_get_name((PurpleBuddy *)cur->data); Data buddyData = buddyToData((PurpleBuddy *)cur->data); instance->_dataModelVars.compound["buddies"].compound[buddyName] = buddyData; } g_slist_free(buddies); delete(ctx); _accountMutex.unlock(); }
static void purple_init( account_t *acc ) { PurplePlugin *prpl = purple_plugins_find_with_id( (char*) acc->prpl->data ); PurplePluginProtocolInfo *pi = prpl->info->extra_info; PurpleAccount *pa; GList *i, *st; set_t *s; char help_title[64]; GString *help; static gboolean dir_fixed = FALSE; /* Layer violation coming up: Making an exception for libpurple here. Dig in the IRC state a bit to get a username. Ideally we should check if s/he identified but this info doesn't seem *that* important. It's just that fecking libpurple can't *not* store this shit. Remember that libpurple is not really meant to be used on public servers anyway! */ if( !dir_fixed ) { irc_t *irc = acc->bee->ui_data; char *dir; dir = g_strdup_printf( "%s/purple/%s", global.conf->configdir, irc->user->nick ); purple_util_set_user_dir( dir ); g_free( dir ); purple_blist_load(); purple_prefs_load(); dir_fixed = TRUE; } help = g_string_new( "" ); g_string_printf( help, "BitlBee libpurple module %s (%s).\n\nSupported settings:", (char*) acc->prpl->name, prpl->info->name ); if( pi->user_splits ) { GList *l; g_string_append_printf( help, "\n* username: Username" ); for( l = pi->user_splits; l; l = l->next ) g_string_append_printf( help, "%c%s", purple_account_user_split_get_separator( l->data ), purple_account_user_split_get_text( l->data ) ); } /* Convert all protocol_options into per-account setting variables. */ for( i = pi->protocol_options; i; i = i->next ) { PurpleAccountOption *o = i->data; const char *name; char *def = NULL; set_eval eval = NULL; void *eval_data = NULL; GList *io = NULL; GSList *opts = NULL; name = purple_account_option_get_setting( o ); switch( purple_account_option_get_type( o ) ) { case PURPLE_PREF_STRING: def = g_strdup( purple_account_option_get_default_string( o ) ); g_string_append_printf( help, "\n* %s (%s), %s, default: %s", name, purple_account_option_get_text( o ), "string", def ); break; case PURPLE_PREF_INT: def = g_strdup_printf( "%d", purple_account_option_get_default_int( o ) ); eval = set_eval_int; g_string_append_printf( help, "\n* %s (%s), %s, default: %s", name, purple_account_option_get_text( o ), "integer", def ); break; case PURPLE_PREF_BOOLEAN: if( purple_account_option_get_default_bool( o ) ) def = g_strdup( "true" ); else def = g_strdup( "false" ); eval = set_eval_bool; g_string_append_printf( help, "\n* %s (%s), %s, default: %s", name, purple_account_option_get_text( o ), "boolean", def ); break; case PURPLE_PREF_STRING_LIST: def = g_strdup( purple_account_option_get_default_list_value( o ) ); g_string_append_printf( help, "\n* %s (%s), %s, default: %s", name, purple_account_option_get_text( o ), "list", def ); g_string_append( help, "\n Possible values: " ); for( io = purple_account_option_get_list( o ); io; io = io->next ) { PurpleKeyValuePair *kv = io->data; opts = g_slist_append( opts, kv->value ); /* TODO: kv->value is not a char*, WTF? */ if( strcmp( kv->value, kv->key ) != 0 ) g_string_append_printf( help, "%s (%s), ", (char*) kv->value, kv->key ); else g_string_append_printf( help, "%s, ", (char*) kv->value ); } g_string_truncate( help, help->len - 2 ); eval = set_eval_list; eval_data = opts; break; default: /** No way to talk to the user right now, invent one when this becomes important. irc_rootmsg( acc->irc, "Setting with unknown type: %s (%d) Expect stuff to break..\n", name, purple_account_option_get_type( o ) ); */ g_string_append_printf( help, "\n* [%s] UNSUPPORTED (type %d)", name, purple_account_option_get_type( o ) ); name = NULL; } if( name != NULL ) { s = set_add( &acc->set, name, def, eval, acc ); s->flags |= ACC_SET_OFFLINE_ONLY; s->eval_data = eval_data; g_free( def ); } } g_snprintf( help_title, sizeof( help_title ), "purple %s", (char*) acc->prpl->name ); help_add_mem( &global.help, help_title, help->str ); g_string_free( help, TRUE ); s = set_add( &acc->set, "display_name", NULL, set_eval_display_name, acc ); s->flags |= ACC_SET_ONLINE_ONLY; if( pi->options & OPT_PROTO_MAIL_CHECK ) { s = set_add( &acc->set, "mail_notifications", "false", set_eval_bool, acc ); s->flags |= ACC_SET_OFFLINE_ONLY; } if( strcmp( prpl->info->name, "Gadu-Gadu" ) == 0 ) s = set_add( &acc->set, "gg_sync_contacts", "true", set_eval_bool, acc ); /* Go through all away states to figure out if away/status messages are possible. */ pa = purple_account_new( acc->user, (char*) acc->prpl->data ); for( st = purple_account_get_status_types( pa ); st; st = st->next ) { PurpleStatusPrimitive prim = purple_status_type_get_primitive( st->data ); if( prim == PURPLE_STATUS_AVAILABLE ) { if( purple_status_type_get_attr( st->data, "message" ) ) acc->flags |= ACC_FLAG_STATUS_MESSAGE; } else if( prim != PURPLE_STATUS_OFFLINE ) { if( purple_status_type_get_attr( st->data, "message" ) ) acc->flags |= ACC_FLAG_AWAY_MESSAGE; } } purple_accounts_remove( pa ); }
int main(int argc, char *argv[]) { GList *iter; int i, num; GList *names = NULL; const char *prpl; char name[128]; char *password; GMainLoop *loop = g_main_loop_new(NULL, FALSE); PurpleAccount *account; PurpleSavedStatus *status; char *res; #ifndef _WIN32 /* libpurple's built-in DNS resolution forks processes to perform * blocking lookups without blocking the main process. It does not * handle SIGCHLD itself, so if the UI does not you quickly get an army * of zombie subprocesses marching around. */ signal(SIGCHLD, SIG_IGN); #endif init_libpurple(); printf("libpurple initialized.\n"); iter = purple_plugins_get_protocols(); for (i = 0; iter; iter = iter->next) { PurplePlugin *plugin = iter->data; PurplePluginInfo *info = plugin->info; if (info && info->name) { printf("\t%d: %s\n", i++, info->name); names = g_list_append(names, info->id); } } printf("Select the protocol [0-%d]: ", i-1); res = fgets(name, sizeof(name), stdin); if (!res) { fprintf(stderr, "Failed to gets protocol selection."); abort(); } sscanf(name, "%d", &num); prpl = g_list_nth_data(names, num); printf("Username: "******"Failed to read user name."); abort(); } name[strlen(name) - 1] = 0; /* strip the \n at the end */ /* Create the account */ account = purple_account_new(name, prpl); /* Get the password for the account */ password = getpass("Password: "); purple_account_set_password(account, password); /* It's necessary to enable the account first. */ purple_account_set_enabled(account, UI_ID, TRUE); /* Now, to connect the account(s), create a status and activate it. */ status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE); purple_savedstatus_activate(status); connect_to_signals_for_demonstration_purposes_only(); g_main_loop_run(loop); return 0; }
int parse(char*toParse, char*ret_buffer, char**uid) { char command = -1, *pCur, *pPrev; int ix, Bound = TK__LAST; taim_session *ses; pCur = toParse; for(ix = 0; ix < Bound; ix++) { if(!strncmp(pCur, g_commands[ix], strlen(g_commands[ix]))) { command = ix; pCur += strlen(g_commands[ix]); break; } } switch(command) { case TK_UID: if(*pCur == ' ') { pCur++; pPrev = pCur; while(*pCur > 32) { pCur ++; } *uid = (char*) malloc(pCur - pPrev); memcpy(*uid, pPrev, pCur - pPrev); (*uid)[pCur - pPrev] = 0; } else { *uid = 0; do { if(*uid != 0) { free(*uid); } *uid = (char*) malloc(KEY_LENGTH + 1); memcpy(*uid, generate_uid(), KEY_LENGTH); } while(uid_addsession(*uid) == 0); } memcpy(ret_buffer, *uid, strlen(*uid)); sprintf(ret_buffer + strlen(*uid) + 1, "\n"); return RET_NODATA; break; case TK_USER: pCur++; pPrev = pCur; while(*pCur > 32 ) { pCur++; } *uid = (char*)malloc(pCur - pPrev + 1); memcpy(*uid, pPrev, pCur - pPrev); (*uid)[pCur - pPrev] = 0; ses = uid_find(*uid); pCur ++; { char *username = pCur; for( ix = 0; username[ix] > ' '; ix++); username[ix] = 0; GList *iter = purple_plugins_get_protocols(); PurplePlugin *plugin = iter->data; PurplePluginInfo *info = plugin->info; printf("<%x>", (unsigned int)ses); fflush(0); if(ses->pses->account == 0) { taim_new_account(ses); } d(username); ses->pses->account->account = purple_account_new(username, info->id); } return RET_NODATA; break; case TK_PASS: pCur++; pPrev = pCur; while(*pCur > 32 ) { pCur++; } *uid = (char*)malloc(pCur - pPrev + 1); memcpy(*uid, pPrev, pCur - pPrev); (*uid)[pCur - pPrev] = 0; pCur ++; ses = uid_find(*uid); { PurpleSavedStatus *status; char *password = pCur, hash[20]; for(ix = 0; password[ix] > ' '; ix++); password[ix] = 0; if(ses->pses->account->hash_have == 1) { // See if the hashes match if(!memcmp(SHA1(password, strlen(password), hash), ses->pses->account->hash, 20)) { // If so, then bond the stuff } else // Otherwise, try to auth anyway { strcpy(ses->pses->account->password_try, password); } purple_account_set_password(ses->pses->account->account, password); purple_account_set_enabled(ses->pses->account->account, UI_ID, TRUE); // Either way, this password is replaced with the new one } else { strcpy(ses->pses->account->password_try, password); purple_account_set_password(ses->pses->account->account, password); purple_account_set_enabled(ses->pses->account->account, UI_ID, TRUE); } // Now, to connect the account(s), create a status and activate it. status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE); purple_savedstatus_activate(status); pthread_mutex_unlock(&g_mutex_init); } return RET_NODATA; break; case TK_GET: pCur++; pPrev = pCur; while(*pCur > 32 ) { pCur++; } *uid = (char*)malloc(pCur - pPrev + 1); memcpy(*uid, pPrev, pCur - pPrev); (*uid)[pCur - pPrev] = 0; pCur ++; if((*uid)[0]) { d(*uid); drecurse(g_blist->root, *uid); return RET_DATA; } else { return RET_NODATA; } break; case TK_SEND: pCur++; pPrev = pCur; while(*pCur > 32 ) { pCur++; } *uid = (char*)malloc(pCur - pPrev + 1); memcpy(*uid, pPrev, pCur - pPrev); (*uid)[pCur - pPrev] = 0; pCur ++; pCur[strlen(pCur) - 1] = 0; taim_send(pCur, *uid, ret_buffer); return RET_NODATA; break; case TK_QUIT: do_exit(); break; default: return RET_ERROR; // unknown command break; } return RET_ERROR; }