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); */
}
