PurpleCmdRet commande(PurpleConversation *conv, const gchar *cmd, gchar **args, gchar **error, void *data) { int argc,pid; char *joueur; char *jeu; joueur=g_strdup_printf("host%d", (int) (999.0*rand()/(RAND_MAX+1.0))); for(argc=0;args[argc];argc++); if(argc==0) { if(error) *error=g_strdup("Il faut spécifier un jeu, les jeux possibles sont(respectez la casse):\n-TicTacToe\n-Reversi\n-Chess"); return PURPLE_CMD_RET_FAILED; } jeu=args[0]; pid=fork(); if(pid==0) { char **parms=malloc(4*sizeof(char *)); char *sys_parm; if(purple_prefs_get_bool("/plugins/gtk/ggzpurple/guest")) { parms[0]=joueur; parms[1]=jeu; sys_parm=g_strdup_printf("%s -u %s -g %s -s %s", GGZWRAPPER, parms[0], parms[1], purple_prefs_get_string("/plugins/gtk/ggzpurple/server")); } else { parms[0]=(char*)purple_prefs_get_string("/plugins/gtk/ggzpurple/login"); parms[1]=jeu; sys_parm=g_strdup_printf("%s -u %s -g %s -p %s -s %s", GGZWRAPPER, parms[0], parms[1], purple_prefs_get_string("/plugins/gtk/ggzpurple/password"), purple_prefs_get_string("/plugins/gtk/ggzpurple/server")); } parms[0]="sh"; parms[1]="-c"; parms[2]=sys_parm; parms[3]=NULL; printf("LAUNCH: %s,%s %s %s\n", "/bin/sh", parms[0], parms[1], parms[2]); execv("/bin/sh", parms); exit(0); } else if(pid>0) { if(purple_prefs_get_bool("/plugins/gtk/ggzpurple/guest")) purple_conv_im_send(PURPLE_CONV_IM(conv), g_strdup_printf("%s%s %s %s", HEADER, jeu,joueur, FOOTER)); else purple_conv_im_send(PURPLE_CONV_IM(conv), g_strdup_printf("%s%s %s %s", HEADER, jeu,purple_prefs_get_string("/plugins/gtk/ggzpurple/login"), FOOTER)); LastGamePID = pid; return PURPLE_CMD_RET_OK; } else { if(error) *error=strdup("Probleme de fork()"); return PURPLE_CMD_RET_FAILED; } }
void PurpleLine::write_message(PurpleConversation *conv, std::string &from, std::string &text, time_t mtime, int flags) { if (!conv) return; PurpleConversationType type = purple_conversation_get_type(conv); if (type == PURPLE_CONV_TYPE_IM) { purple_conv_im_write( PURPLE_CONV_IM(conv), from.c_str(), text.c_str(), (PurpleMessageFlags)flags, mtime); } else if (type == PURPLE_CONV_TYPE_CHAT) { purple_conv_chat_write( PURPLE_CONV_CHAT(conv), from.c_str(), text.c_str(), (PurpleMessageFlags)flags, mtime); } else { purple_debug_warning("line", "write_message for weird conversation type: %d\n", type); } }
gboolean pop(gpointer p) { char *reply = ""; queue_t *q = (queue_t*)p; queue_item_t *item; if (q->len > 0) { item = q->q[0]; q->len--; if (q->len > 0) { memmove(q->q, &(q->q[1]), q->len * sizeof(queue_item_t*)); // q->q = realloc(q->q, q->len * sizeof(queue_item_t*)); } if (purple_conversation_get_type(item->conv) == PURPLE_CONV_TYPE_IM) { // reply = alice(item->name, item->msg, item->conv); purple_conv_im_send(PURPLE_CONV_IM(item->conv), item->msg); } else if (purple_conversation_get_type(item->conv) == PURPLE_CONV_TYPE_CHAT) { // reply = alice(item->name, item->msg, item->conv); purple_conv_chat_send(PURPLE_CONV_CHAT(item->conv), item->msg); } printf (NAME ": %s\n", reply); free(item->name); free(item->msg); free(item); } return 1; }
static void pidginwhiteboard_button_start_press(GtkButton *button, gpointer data) { PurpleConversation *conv = data; PurpleAccount *account = purple_conversation_get_account(conv); PurpleConnection *gc = purple_account_get_connection(account); char *to = (char*)(purple_conversation_get_name(conv)); /* Only handle this if local client requested Doodle session (else local * client would have sent one) */ PurpleWhiteboard *wb = purple_whiteboard_get(account, to); /* Write a local message to this conversation showing that a request for a * Doodle session has been made */ /* XXXX because otherwise gettext will see this string, even though it's * in an #if 0 block. Remove the XXXX if you want to use this code. * But, it really shouldn't be a Yahoo-specific string. ;) */ purple_conv_im_write(PURPLE_CONV_IM(conv), "", XXXX_("Sent Doodle request."), PURPLE_MESSAGE_NICK | PURPLE_MESSAGE_RECV, time(NULL)); yahoo_doodle_command_send_request(gc, to); yahoo_doodle_command_send_ready(gc, to); /* Insert this 'session' in the list. At this point, it's only a requested * session. */ wb = purple_whiteboard_create(account, to, DOODLE_STATE_REQUESTING); }
void gevo_add_buddy(PurpleAccount *account, const char *group_name, const char *buddy_name, const char *alias) { PurpleConversation *conv = NULL; PurpleBuddy *buddy; PurpleGroup *group; conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, buddy_name, account); group = purple_find_group(group_name); if (group == NULL) { group = purple_group_new(group_name); purple_blist_add_group(group, NULL); } buddy = purple_find_buddy_in_group(account, buddy_name, group); if (buddy == NULL) { buddy = purple_buddy_new(account, buddy_name, alias); purple_blist_add_buddy(buddy, NULL, group, NULL); } purple_account_add_buddy(account, buddy); if (conv != NULL) { purple_buddy_icon_update(purple_conv_im_get_icon(PURPLE_CONV_IM(conv))); purple_conversation_update(conv, PURPLE_CONV_UPDATE_ADD); } }
void SpectrumConversation::sendMessage(boost::shared_ptr<Swift::Message> &message) { // escape and send gchar *_markup = purple_markup_escape_text(message->getBody().c_str(), -1); if (purple_conversation_get_type(m_conv) == PURPLE_CONV_TYPE_IM) { purple_conv_im_send(PURPLE_CONV_IM(m_conv), _markup); } g_free(_markup); }
static void bud(PurpleBuddy *who) { PurpleAccount *acct = who->account; PurpleConversation *conv = purple_im_conversation_new(acct, who->name); purple_im_conversation_send(PURPLE_CONV_IM(conv), "Hello!"); }
static void signed_on(PurpleConnection *gc) { PurpleAccount *account = purple_connection_get_account(gc); PurpleConversation *conv; conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, input_address); purple_conv_im_send(PURPLE_CONV_IM(conv), input_message); exit(0); }
void update_buddy_typing_cb(PurpleAccount *account, const char *who) { PurpleConversation *gConv = NULL; gConv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, who, account); if (!gConv) return; PurpleChatMngr::UpdateBuddyTyping(gConv, purple_conv_im_get_typing_state(PURPLE_CONV_IM(gConv))); }
bool PurpleIMChat::sendMessageCbk(void * dataIn) { Mutex::ScopedLock lock(PurpleIMChat::_mutex); PurpleIMChatCallbackData* cbData = (PurpleIMChatCallbackData*) dataIn; IMChatSession* chatSession = cbData->getIMChatSession(); // const char * message = (const char *)((misc_t *)data)->data_ptr2; // char *cleanMess = (char *) message; // bool cleaned = false; std::string cleanMsg = cbData->getMessage(); mConvInfo_t *mConv = FindChatStructById(chatSession->getId()); PurpleConversation *gConv = mConv->purple_conv_session; //VOXOX - JRT - 2009.07.09 // special case for ICQ PurpleAccount *gAccount = purple_conversation_get_account(gConv); PurplePlugin *prpl = purple_find_prpl(purple_account_get_protocol_id(gAccount)); if (prpl) { PurplePluginProtocolInfo *prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl); if (prpl_info->list_icon != NULL) { if (!strcmp("icq", prpl_info->list_icon(gAccount, NULL))) { // cleanMess = (char *) purple_markup_strip_html(message); cleanMsg= purple_markup_strip_html( cbData->getMessage().c_str() ); // cleaned = true; } } } if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_IM) { purple_conv_im_send_with_flags(PURPLE_CONV_IM(gConv), cleanMsg.c_str(), PURPLE_MESSAGE_SEND); } else if (purple_conversation_get_type(gConv) == PURPLE_CONV_TYPE_CHAT) { purple_conv_chat_send_with_flags(PURPLE_CONV_CHAT(gConv), cleanMsg.c_str(), PURPLE_MESSAGE_SEND); } // if (cleaned) // { // g_free(cleanMess); // } timeoutRemove( cbData ); delete cbData; return TRUE; }
static PurpleCmdRet radio_callback(PurpleConversation* conv, const gchar* cmd, gchar** args, gchar** error, void* data) { char* radio_msg = radio_str(args[0]); purple_conv_im_send(PURPLE_CONV_IM(conv), radio_msg); return PURPLE_CMD_RET_OK; }
static VALUE conversation_im_send(VALUE self, VALUE message) { PurpleConversation *conversation; Data_Get_Struct(self, PurpleConversation, conversation); PurpleConvIm *im_data = PURPLE_CONV_IM(conversation); if (im_data == NULL) { return Qnil; } else { purple_conv_im_send(im_data, StringValueCStr(message)); return Qtrue; } }
void Buddy::Send (ConvIMMessage *msg) { auto name = purple_buddy_get_name (Buddy_); if (!name) { qWarning () << Q_FUNC_INFO << "unable to get buddy name" << Name_; const auto& notify = Util::MakeNotification ("Azoth VelvetBird", tr ("Unable to send message: protocol error.") .arg (name), Priority::Info); const auto& proxy = Account_->GetParentProtocol ()->GetCoreProxy (); proxy->GetEntityManager ()->HandleEntity (notify); return; } auto conv = purple_find_conversation_with_account (PURPLE_CONV_TYPE_IM, name, Account_->GetPurpleAcc ()); if (!conv) { conv = purple_conversation_new (PURPLE_CONV_TYPE_IM, Account_->GetPurpleAcc (), name); if (!conv) { qWarning () << Q_FUNC_INFO << "unable to create conversation with" << name; const auto& notify = Util::MakeNotification ("Azoth VelvetBird", tr ("Unable to send message to %1: protocol error.") .arg (name), Priority::Info); const auto& proxy = Account_->GetParentProtocol ()->GetCoreProxy (); proxy->GetEntityManager ()->HandleEntity (notify); return; } conv->ui_data = this; purple_conversation_set_logging (conv, false); } Store (msg); purple_conv_im_send (PURPLE_CONV_IM (conv), msg->GetBody ().toUtf8 ().constData ()); }
/** * A function to send a chat or im message to the specific conversation * without emitting "sending-im" or "sending-chat" signal, which would * cause an infinite loop for this plugin. * * taken from conversation.c with signal emission removed. */ static void splitter_common_send(PurpleConversation *conv, const char *message, PurpleMessageFlags msgflags) { PurpleConversationType type; PurpleAccount *account; PurpleConnection *gc; char *sent = NULL; if (strlen(message) == 0) return; account = purple_conversation_get_account(conv); #if PURPLE_VERSION_CHECK(3,0,0) gc = purple_conversation_get_connection(conv); #else gc = purple_conversation_get_gc(conv); #endif g_return_if_fail(account != NULL); g_return_if_fail(gc != NULL); type = purple_conversation_get_type(conv); if ((purple_conversation_get_features(conv) & PURPLE_CONNECTION_HTML) && !(msgflags & PURPLE_MESSAGE_RAW)) { sent = purple_markup_linkify(message); } else sent = g_strdup(message); msgflags |= PURPLE_MESSAGE_SEND; splitter_injected_message = TRUE; if (type == PURPLE_CONV_TYPE_IM) { if (sent != NULL && sent[0] != '\0') purple_conv_im_send_with_flags(PURPLE_CONV_IM(conv), sent, msgflags); } else { if (sent != NULL && sent[0] != '\0') purple_conv_chat_send_with_flags(PURPLE_CONV_CHAT(conv), sent, msgflags); } splitter_injected_message = FALSE; g_free(sent); }
void purple_prpl_send_attention(PurpleConnection *gc, const char *who, guint type_code) { PurpleAttentionType *attn; PurpleMessageFlags flags; PurplePlugin *prpl; PurpleConversation *conv; gboolean (*send_attention)(PurpleConnection *, const char *, guint); PurpleBuddy *buddy; const char *alias; gchar *description; time_t mtime; g_return_if_fail(gc != NULL); g_return_if_fail(who != NULL); prpl = purple_find_prpl(purple_account_get_protocol_id(gc->account)); send_attention = PURPLE_PLUGIN_PROTOCOL_INFO(prpl)->send_attention; g_return_if_fail(send_attention != NULL); mtime = time(NULL); attn = purple_get_attention_type_from_code(gc->account, type_code); if ((buddy = purple_find_buddy(purple_connection_get_account(gc), who)) != NULL) alias = purple_buddy_get_contact_alias(buddy); else alias = who; if (attn && purple_attention_type_get_outgoing_desc(attn)) { description = g_strdup_printf(purple_attention_type_get_outgoing_desc(attn), alias); } else { description = g_strdup_printf(_("Requesting %s's attention..."), alias); } flags = PURPLE_MESSAGE_SEND | PURPLE_MESSAGE_NOTIFY | PURPLE_MESSAGE_SYSTEM; purple_debug_info("server", "serv_send_attention: sending '%s' to %s\n", description, who); if (!send_attention(gc, who, type_code)) return; conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, gc->account, who); purple_conv_im_write(PURPLE_CONV_IM(conv), NULL, description, flags, mtime); purple_prpl_attention(conv, who, type_code, PURPLE_MESSAGE_SEND, time(NULL)); g_free(description); }
static void buddy_typing_cb(PurpleAccount *acct, const char *name, void *data) { PurpleConversation *gconv; if(purple_prefs_get_bool(PREF_STATUS) && ! purple_status_is_available(purple_account_get_active_status(acct))) { purple_debug_info("psychic", "not available, doing nothing\n"); return; } if(purple_prefs_get_bool(PREF_BUDDIES) && ! purple_find_buddy(acct, name)) { purple_debug_info("psychic", "not in blist, doing nothing\n"); return; } if(FALSE == purple_privacy_check(acct, name)) { purple_debug_info("psychic", "user %s is blocked\n", name); return; } gconv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, name, acct); if(! gconv) { purple_debug_info("psychic", "no previous conversation exists\n"); gconv = purple_conversation_new(PURPLE_CONV_TYPE_IM, acct, name); if(purple_prefs_get_bool(PREF_RAISE)) { purple_conversation_present(gconv); } if(purple_prefs_get_bool(PREF_NOTICE)) { /* This is a quote from Star Wars. You should probably not translate it literally. If you can't find a fitting cultural reference in your language, consider translating something like this instead: "You feel a new message coming." */ purple_conversation_write(gconv, NULL, _("You feel a disturbance in the force..."), PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG | PURPLE_MESSAGE_ACTIVE_ONLY, time(NULL)); } /* Necessary because we may be creating a new conversation window. */ purple_conv_im_set_typing_state(PURPLE_CONV_IM(gconv), PURPLE_TYPING); } }
static PurpleCmdRet cmd_func(PurpleConversation *conv, const gchar *cmd, gchar **args, gchar *error, void *data) { GString *msgstr = NULL; guint32 quotes = 0, quoteid = 0; msgstr = g_string_new(""); srand(time(NULL)); if(!strcmp(cmd, "bash")) { g_string_append(msgstr, "http://www.bash.org/?"); quotes = BASH_QUOTES; } else { g_string_append(msgstr, "http://qdb.us/"); quotes = QDB_QUOTES; } if(*args == NULL || args[0] == NULL) quoteid = (rand() % quotes) + 1; else quoteid = atoi(args[0]); if(quoteid > quotes) quoteid %= quotes; g_string_append_printf(msgstr, "%i", quoteid); switch(purple_conversation_get_type(conv)) { case PURPLE_CONV_TYPE_IM: purple_conv_im_send(PURPLE_CONV_IM(conv), msgstr->str); break; case PURPLE_CONV_TYPE_CHAT: purple_conv_chat_send(PURPLE_CONV_CHAT(conv), msgstr->str); break; default: g_string_free(msgstr, TRUE); return PURPLE_CMD_RET_FAILED; } g_string_free(msgstr, TRUE); return PURPLE_CMD_RET_OK; }
static PurpleCmdRet send_to_all(PurpleConversation *conv, const gchar *cmd, gchar **markup, gchar *error, void *data) { PurpleConversation *conversation = NULL; GList *conversations = purple_get_conversations(); while(conversations != NULL) { conversation = conversations->data; if(conv->type == PURPLE_CONV_TYPE_IM) purple_conv_im_send(PURPLE_CONV_IM(conversation), markup[0]); else if(conv->type == PURPLE_CONV_TYPE_CHAT) purple_conv_chat_send(PURPLE_CONV_CHAT(conversation), markup[0]); conversations = conversations->next; } //g_free(msg); return PURPLE_CMD_RET_OK; }
void music_messaging_change_confirmed(const int session, const char *command, const char *parameters) { MMConversation *mmconv = (MMConversation *)g_list_nth_data(conversations, session); if (mmconv->started) { if (mmconv->originator) { GString *to_send = g_string_new(""); g_string_append_printf(to_send, "##MM## confirm %s %s##MM##", command, parameters); purple_conv_im_send(PURPLE_CONV_IM(mmconv->conv), to_send->str); } else { /* Do nothing. If they aren't the originator, then they can't confirm. */ } } }
void irc_msg_pong(struct irc_conn *irc, const char *name, const char *from, char **args) { PurpleConversation *convo; PurpleConnection *gc; char **parts, *msg; time_t oldstamp; if (!args || !args[1]) return; parts = g_strsplit(args[1], " ", 2); if (!parts[0] || !parts[1]) { g_strfreev(parts); return; } if (sscanf(parts[1], "%lu", &oldstamp) != 1) { msg = g_strdup(_("Error: invalid PONG from server")); } else { msg = g_strdup_printf(_("PING reply -- Lag: %lu seconds"), time(NULL) - oldstamp); } convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY, parts[0], irc->account); g_strfreev(parts); if (convo) { if (purple_conversation_get_type (convo) == PURPLE_CONV_TYPE_CHAT) purple_conv_chat_write(PURPLE_CONV_CHAT(convo), "PONG", msg, PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL)); else purple_conv_im_write(PURPLE_CONV_IM(convo), "PONG", msg, PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL)); } else { gc = purple_account_get_connection(irc->account); if (!gc) { g_free(msg); return; } purple_notify_info(gc, NULL, "PONG", msg); } g_free(msg); }
/****************************************************************************** * Functions *****************************************************************************/ PurpleCmdRet yahoo_doodle_purple_cmd_start(PurpleConversation *conv, const char *cmd, char **args, char **error, void *data) { PurpleAccount *account; PurpleConnection *gc; const gchar *name; if(*args && args[0]) return PURPLE_CMD_RET_FAILED; account = purple_conversation_get_account(conv); gc = purple_account_get_connection(account); name = purple_conversation_get_name(conv); yahoo_doodle_initiate(gc, name); /* Write a local message to this conversation showing that a request for a * Doodle session has been made */ purple_conv_im_write(PURPLE_CONV_IM(conv), "", _("Sent Doodle request."), PURPLE_MESSAGE_NICK | PURPLE_MESSAGE_RECV, time(NULL)); return PURPLE_CMD_RET_OK; }
static VALUE common_send(VALUE self, VALUE name, VALUE message) { PurpleAccount *account; Data_Get_Struct(self, PurpleAccount, account); if (purple_account_is_connected(account)) { PurpleBuddy* buddy = purple_find_buddy(account, RSTRING_PTR(name)); if (buddy != NULL) { PurpleConversation *conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, RSTRING_PTR(name), account); if (conv == NULL) { conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, buddy->account, buddy->name); } purple_conv_im_send(PURPLE_CONV_IM(conv), RSTRING_PTR(message)); return INT2FIX(0); } else { return Qnil; } } else { return Qnil; } }
gboolean jidgin_worker_send_im(PurpleAccount *account, PurpleConversation *conv, pJidginMsg pmsg) { PurpleBuddy *buddy; char *reply; pJidginSetting setting = jidgin_core_get_purple_settings(); if (!account) { account = jidgin_core_get_primary_account(); } if (purple_account_is_disconnected(account)) { jidgin_log(LOG_INFO, "[jidgin_worker_send_im]%s disconnected\n", purple_account_get_username(account)); jidgin_worker_cb_retry(account); return FALSE; } if (!conv) { buddy = purple_find_buddy(account, pmsg->from); if (!buddy) { if (setting && setting->is_force_mt) buddy = purple_buddy_new(account, pmsg->from, pmsg->from); else return FALSE; } conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, buddy->account, pmsg->from); } jidgin_log(LOG_INFO, "[jidgin_worker_send_im]%s %s\n", purple_account_get_username(account), pmsg->from); if (jidgin_intercept_postrouting(pmsg->msg, &reply)) { g_free(pmsg->msg); pmsg->msg = reply; } purple_conv_im_send(PURPLE_CONV_IM(conv), pmsg->msg); return TRUE; }
/* Exported functions */ void music_messaging_change_request(const int session, const char *command, const char *parameters) { MMConversation *mmconv = (MMConversation *)g_list_nth_data(conversations, session); if (mmconv->started) { if (mmconv->originator) { char *name = (mmconv->conv)->name; send_change_request (session, name, command, parameters); } else { GString *to_send = g_string_new(""); g_string_append_printf(to_send, "##MM## request %s %s##MM##", command, parameters); purple_conv_im_send(PURPLE_CONV_IM(mmconv->conv), to_send->str); purple_debug_misc("musicmessaging", "Sent request: %s\n", to_send->str); } } }
/* No, this is not a ui_op but a signal. */ static void prplcb_buddy_typing( PurpleAccount *account, const char *who, gpointer null ) { PurpleConversation *conv; PurpleConvIm *im; int state; if( ( conv = purple_find_conversation_with_account( PURPLE_CONV_TYPE_IM, who, account ) ) == NULL ) return; im = PURPLE_CONV_IM(conv); switch( purple_conv_im_get_typing_state( im ) ) { case PURPLE_TYPING: state = OPT_TYPING; break; case PURPLE_TYPED: state = OPT_THINKING; break; default: state = 0; } imcb_buddy_typing( purple_ic_by_pa( account ), who, state ); }
void irc_msg_nonick(struct irc_conn *irc, const char *name, const char *from, char **args) { PurpleConnection *gc; PurpleConversation *convo; convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_ANY, args[1], irc->account); if (convo) { if (purple_conversation_get_type(convo) == PURPLE_CONV_TYPE_CHAT) /* does this happen? */ purple_conv_chat_write(PURPLE_CONV_CHAT(convo), args[1], _("no such channel"), PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL)); else purple_conv_im_write(PURPLE_CONV_IM(convo), args[1], _("User is not logged in"), PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL)); } else { if ((gc = purple_account_get_connection(irc->account)) == NULL) return; purple_notify_error(gc, NULL, _("No such nick or channel"), args[1]); } if (irc->whois.nick && !purple_utf8_strcasecmp(irc->whois.nick, args[1])) { g_free(irc->whois.nick); irc->whois.nick = NULL; } }
static void write_conv(PurpleConversation *conv, const char *who, const char *alias, const char *message, PurpleMessageFlags flags, time_t mtime) { if (!(flags & PURPLE_MESSAGE_RECV)) return; const char *name; if (alias && *alias) name = alias; else if (who && *who) name = who; else name = NULL; printf("(%s) %s %s: %s\n", purple_conversation_get_name(conv), purple_utf8_strftime("(%H:%M:%S)", localtime(&mtime)), name, message); time_t rawtime; char send_message[5120]; get_answer(message, &send_message[0]); //printf("%s", send_message); purple_conv_im_send(PURPLE_CONV_IM(conv), send_message); }
static void message_recu2(PurpleAccount *acct,char **sender, char **buffer,int flags, PurpleConversation *conv,void *data) { GtkWidget *pDialog; if(*buffer==NULL) return; if(strstr(*buffer, HEADER)==NULL) return; char *joueur=NULL; char *jeu=NULL; jeu=strstr(*buffer, HEADER); jeu+=strlen(HEADER); jeu[strlen(jeu)-strlen(strstr(jeu, FOOTER))]='\0'; joueur=index(jeu, ' '); if(strstr(jeu,"refuse_game") != NULL) { pDialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK, g_strdup_printf("Votre partie avec %s a été refusée/annulée !",*sender)); gtk_dialog_run(GTK_DIALOG(pDialog)); gtk_widget_destroy(pDialog); //printf("Test : %d\n",LastGamePID); //kill(LastGamePID, SIGKILL); *buffer = NULL; return; } if(joueur==NULL) { printf("Pas de joueur mais un jeu: %s\n", jeu); return; } joueur[0]='\0'; joueur++; if(index(joueur, ' ')) { joueur[strlen(joueur) - strlen(index(joueur, ' '))]='\0'; } pDialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, "%s/%s vous propose une partie de %s, voulez vous accepter ?",*sender,joueur,jeu); if(gtk_dialog_run(GTK_DIALOG(pDialog)) == GTK_RESPONSE_NO) { gtk_widget_destroy(pDialog); purple_conv_im_send(PURPLE_CONV_IM(purple_conversation_new(PURPLE_CONV_TYPE_IM,acct,*sender)), g_strdup_printf("%srefuse_game %s", HEADER, FOOTER)); *buffer=NULL; return; } gtk_widget_destroy(pDialog); int pid=0; pid=fork(); if(pid==0) { //L'enfant trop fort hein :) char **parms=malloc(4*sizeof(char *)); char *sys_parm; if(purple_prefs_get_bool("/plugins/gtk/ggzpurple/guest")) { parms[1]=g_strdup_printf("guest%d", (int) (999.0*rand()/(RAND_MAX+1.0))); parms[2]=joueur; sys_parm=g_strdup_printf("%s -u %s -d %s -g %s -s %s", GGZWRAPPER, parms[1], parms[2], jeu, purple_prefs_get_string("/plugins/gtk/ggzpurple/server")); } else { parms[1]=(char*)purple_prefs_get_string("/plugins/gtk/ggzpurple/login"); parms[2]=joueur; sys_parm=g_strdup_printf("%s -u %s -d %s -g %s -p %s -s %s", GGZWRAPPER, parms[1], parms[2], jeu, purple_prefs_get_string("/plugins/gtk/ggzpurple/password"), purple_prefs_get_string("/plugins/gtk/ggzpurple/server")); } parms[0]="sh"; parms[1]="-c"; parms[2]=sys_parm; parms[3]=NULL; printf("LAUNCH: %s,%s %s %s\n", "/bin/sh", parms[0], parms[1], parms[2]); execv("/bin/sh", parms); exit(0); } else if(pid>0) { //Ici c'est le pere je vous apprends beaucoup de choses non? ;) //LastGamePID = pid; } else { //Ici c'est quand y a eu une erreur........ } //Ca sert a rien d'afficher ce somtueux message ;) *buffer=NULL; }
void msn_got_rem_user(MsnSession *session, MsnUser *user, MsnListId list_id, int group_id) { PurpleAccount *account; const char *passport; account = session->account; passport = msn_user_get_passport(user); if (list_id == MSN_LIST_FL) { /* TODO: When is the user totally removed? */ if (group_id >= 0) { msn_user_remove_group_id(user, group_id); return; } else { /* session->sync->fl_users_count--; */ } } else if (list_id == MSN_LIST_AL) { purple_privacy_permit_remove(account, passport, TRUE); } else if (list_id == MSN_LIST_BL) { purple_privacy_deny_remove(account, passport, TRUE); } else if (list_id == MSN_LIST_RL) { PurpleConversation *convo; purple_debug_info("msn", "%s has removed you from his or her buddy list.\n", passport); convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, passport, account); if (convo) { PurpleBuddy *buddy; char *msg; buddy = purple_find_buddy(account, passport); msg = g_strdup_printf( _("%s has removed you from his or her buddy list."), buddy ? purple_buddy_get_contact_alias(buddy) : passport); purple_conv_im_write(PURPLE_CONV_IM(convo), passport, msg, PURPLE_MESSAGE_SYSTEM, time(NULL)); g_free(msg); } } user->list_op &= ~(1 << list_id); /* purple_user_remove_list_id (user, list_id); */ if (user->list_op == 0) { purple_debug_info("msn", "Buddy '%s' shall be deleted?.\n", passport); } }
void msn_got_add_user(MsnSession *session, MsnUser *user, MsnListId list_id, int group_id) { PurpleAccount *account; const char *passport; const char *friendly; account = session->account; passport = msn_user_get_passport(user); friendly = msn_user_get_friendly_name(user); if (list_id == MSN_LIST_FL) { PurpleConnection *gc; gc = purple_account_get_connection(account); serv_got_alias(gc, passport, friendly); if (group_id >= 0) { msn_user_add_group_id(user, group_id); } else { /* session->sync->fl_users_count++; */ } } else if (list_id == MSN_LIST_AL) { purple_privacy_permit_add(account, passport, TRUE); } else if (list_id == MSN_LIST_BL) { purple_privacy_deny_add(account, passport, TRUE); } else if (list_id == MSN_LIST_RL) { PurpleConnection *gc; PurpleConversation *convo; gc = purple_account_get_connection(account); purple_debug_info("msn", "%s has added you to his or her buddy list.\n", passport); convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, passport, account); if (convo) { PurpleBuddy *buddy; char *msg; buddy = purple_find_buddy(account, passport); msg = g_strdup_printf( _("%s has added you to his or her buddy list."), buddy ? purple_buddy_get_contact_alias(buddy) : passport); purple_conv_im_write(PURPLE_CONV_IM(convo), passport, msg, PURPLE_MESSAGE_SYSTEM, time(NULL)); g_free(msg); } if (!(user->list_op & (MSN_LIST_AL_OP | MSN_LIST_BL_OP))) { /* * TODO: The friendly name was NULL for me when I * looked at this. Maybe we should use the store * name instead? --KingAnt */ got_new_entry(gc, passport, friendly); } } user->list_op |= (1 << list_id); /* purple_user_add_list_id (user, list_id); */ }