Changes in / [5014380:b8c336b]


Ignore:
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • irc.h

    r5014380 rb8c336b  
    147147        IRC_CHANNEL_TEMP = 2,   /* Erase the channel when the user leaves,
    148148                                   and don't save it. */
     149
     150        /* Show a placeholder of the channel in listings, but don't save it */
     151        IRC_CHANNEL_KEEP_PLACEHOLDER = 4,
    149152
    150153        /* Hack: Set this flag right before jumping into IM when we expect

  • irc_channel.c

    r5014380 rb8c336b  
    276276                if (ic->irc->status & USTATUS_SHUTDOWN) {
    277277                        /* Don't do anything fancy when we're shutting down anyway. */
    278                 } else if (ic->flags & IRC_CHANNEL_TEMP) {
     278                } else if (ic->flags & IRC_CHANNEL_TEMP && !(ic->flags & IRC_CHANNEL_KEEP_PLACEHOLDER)) {
    279279                        irc_channel_free_soon(ic);
    280280                } else {

  • irc_im.c

    r5014380 rb8c336b  
    576576        ic->data = c;
    577577
    578         topic = g_strdup_printf(
    579                 "BitlBee groupchat: \"%s\". Please keep in mind that root-commands won't work here. Have fun!",
    580                 c->title);
    581         irc_channel_set_topic(ic, topic, irc->root);
    582         g_free(topic);
     578        if (ic->topic == NULL) {
     579                /* New channel with no preset topic - make up a generic one */
     580                topic = g_strdup_printf(
     581                        "BitlBee groupchat: \"%s\". Please keep in mind that root-commands won't work here. Have fun!",
     582                        c->title);
     583                irc_channel_set_topic(ic, topic, irc->root);
     584        } else {
     585                /* Preset topic from the channel we picked */
     586                topic = g_strdup(ic->topic);
     587        }
     588
     589        g_free(c->topic);
     590        c->topic = topic;         /* Let groupchat borrow this pointer */
    583591
    584592        return TRUE;
    … …  
    600608        c->ui_data = NULL;
    601609        irc_channel_del_user(ic, ic->irc->user, IRC_CDU_KICK, "Chatroom closed by server");
     610
     611        return TRUE;
     612}
     613
     614static gboolean bee_irc_chat_placeholder_new(bee_t *bee, struct im_connection *ic, const char *handle,
     615                                             const char *name, const char *topic)
     616{
     617        irc_t *irc = bee->ui_data;
     618        irc_channel_t *ircc;
     619        char *full_name = irc_channel_name_gen(irc, name);
     620
     621        ircc = irc_channel_new(irc, full_name);
     622
     623        set_setstr(&ircc->set, "type", "chat");
     624        set_setstr(&ircc->set, "chat_type", "placeholder");
     625        set_setstr(&ircc->set, "account", ic->acc->tag);
     626        set_setstr(&ircc->set, "room", (char *) handle);
     627
     628        irc_channel_set_topic(ircc, topic, NULL);
     629
     630        g_free(full_name);
    602631
    603632        return TRUE;
    … …  
    826855static gboolean bee_irc_channel_chat_join(irc_channel_t *ic)
    827856{
    828         char *acc_s, *room;
     857        char *acc_s, *room, *chat_type;
    829858        account_t *acc;
    830859
    831         if (strcmp(set_getstr(&ic->set, "chat_type"), "room") != 0) {
     860        chat_type = set_getstr(&ic->set, "chat_type");
     861
     862        if (strcmp(chat_type, "room") != 0 && strcmp(chat_type, "placeholder") != 0) {
    832863                return TRUE;
    833864        }
    … …  
    9851016        struct irc_channel *ic = set->data;
    9861017
     1018        ic->flags &= ~(IRC_CHANNEL_TEMP | IRC_CHANNEL_KEEP_PLACEHOLDER);
     1019
    9871020        if (strcmp(value, "groupchat") == 0) {
    9881021                ic->flags |= IRC_CHANNEL_TEMP;
    9891022        } else if (strcmp(value, "room") == 0) {
    990                 ic->flags &= ~IRC_CHANNEL_TEMP;
     1023                // beep boop
     1024        } else if (strcmp(value, "placeholder") == 0) {
     1025                ic->flags |= IRC_CHANNEL_TEMP | IRC_CHANNEL_KEEP_PLACEHOLDER;
    9911026        } else {
    9921027                return NULL;
    … …  
    10721107        bee_irc_chat_new,
    10731108        bee_irc_chat_free,
     1109        bee_irc_chat_placeholder_new,
    10741110        bee_irc_chat_log,
    10751111        bee_irc_chat_msg,

  • protocols/bee.h

    r5014380 rb8c336b  
    115115        gboolean (*chat_new)(bee_t *bee, struct groupchat *c);
    116116        gboolean (*chat_free)(bee_t *bee, struct groupchat *c);
     117        gboolean (*chat_placeholder_new)(bee_t *bee, struct im_connection *ic, const char *handle,
     118                                         const char *name, const char *topic);
    117119        /* System messages of any kind. */
    118120        gboolean (*chat_log)(bee_t *bee, struct groupchat *c, const char *text);
    … …  
    165167 *   user, too. */
    166168G_MODULE_EXPORT struct groupchat *imcb_chat_new(struct im_connection *ic, const char *handle);
     169G_MODULE_EXPORT void imcb_chat_placeholder_new(struct im_connection *ic, const char *handle, const char *name,
     170                                               const char *topic);
    167171G_MODULE_EXPORT void imcb_chat_name_hint(struct groupchat *c, const char *name);
    168172G_MODULE_EXPORT void imcb_chat_free(struct groupchat *c);

  • protocols/bee_chat.c

    r5014380 rb8c336b  
    5454}
    5555
     56void imcb_chat_placeholder_new(struct im_connection *ic, const char *handle, const char *name, const char *topic)
     57{
     58        bee_t *bee = ic->bee;
     59
     60        if (bee->ui->chat_placeholder_new) {
     61                bee->ui->chat_placeholder_new(bee, ic, handle, name, topic);
     62        }
     63}
     64
    5665void imcb_chat_name_hint(struct groupchat *c, const char *name)
    5766{

  • protocols/jabber/conference.c

    r5014380 rb8c336b  
    354354        struct xt_node *subject = xt_find_node(node->children, "subject");
    355355        struct xt_node *body = xt_find_node(node->children, "body");
    356         struct groupchat *chat = bud ? jabber_chat_by_jid(ic, bud->bare_jid) : NULL;
    357         struct jabber_chat *jc = chat ? chat->data : NULL;
    358         char *s;
     356        struct groupchat *chat = NULL;
     357        struct jabber_chat *jc = NULL;
     358        char *from = NULL;
     359        char *nick = NULL;
     360        char *final_from = NULL;
     361        char *bare_jid = NULL;
     362
     363        from = (bud) ? bud->full_jid : xt_find_attr(node, "from");
     364
     365        if (from) {
     366                nick = strchr(from, '/');
     367                if (nick) {
     368                        *nick = 0;
     369                }
     370                chat = jabber_chat_by_jid(ic, from);
     371                if (nick) {
     372                        *nick = '/';
     373                        nick++;
     374                }
     375        }
     376
     377        jc = (chat) ? chat->data : NULL;
     378
     379        if (!bud) {
     380                struct xt_node *c;
     381                char *s;
     382
     383                /* Try some clever stuff to find out the real JID here */
     384                c = xt_find_node_by_attr(node->children, "delay", "xmlns", XMLNS_DELAY);
     385
     386                if (c && ((s = xt_find_attr(c, "from")) ||
     387                          (s = xt_find_attr(c, "from_jid")))) {
     388                        /* This won't be useful if it's the MUC JID */
     389                        if (!(jc && jabber_compare_jid(s, jc->name))) {
     390                                /* Hopefully this one makes more sense! */
     391                                bud = jabber_buddy_by_jid(ic, s, GET_BUDDY_FIRST | GET_BUDDY_CREAT);
     392                        }
     393                }
     394
     395        }
    359396
    360397        if (subject && chat) {
    361                 s = (bud && bud->ext_jid) ? strchr(bud->ext_jid, '/') : NULL;
    362                 if (s) {
    363                         *s = 0;
    364                 }
    365                 imcb_chat_topic(chat, bud ? bud->ext_jid : NULL, subject->text_len > 0 ?
    366                                 subject->text : NULL, jabber_get_timestamp(node));
    367                 if (s) {
    368                         *s = '/';
    369                 }
    370         }
    371 
    372         if (bud == NULL || (jc && ~jc->flags & JCFLAG_MESSAGE_SENT && bud == jc->me)) {
    373                 char *nick;
    374 
    375                 if (body == NULL || body->text_len == 0) {
    376                         /* Meh. Empty messages aren't very interesting, no matter
    377                            how much some servers love to send them. */
    378                         return;
    379                 }
    380 
    381                 s = xt_find_attr(node, "from");   /* pkt_message() already NULL-checked this one. */
    382                 nick = strchr(s, '/');
    383                 if (nick) {
    384                         /* If this message included a resource/nick we don't know,
    385                            we might still know the groupchat itself. */
    386                         *nick = 0;
    387                         chat = jabber_chat_by_jid(ic, s);
    388                         *nick = '/';
    389 
    390                         nick++;
     398                char *subject_text = subject->text_len > 0 ? subject->text : NULL;
     399                if (g_strcmp0(chat->topic, subject_text) != 0) {
     400                        bare_jid = (bud) ? jabber_get_bare_jid(bud->ext_jid) : NULL;
     401                        imcb_chat_topic(chat, bare_jid, subject_text,
     402                                        jabber_get_timestamp(node));
     403                        g_free(bare_jid);
     404                }
     405        }
     406
     407        if (body == NULL || body->text_len == 0) {
     408                /* Meh. Empty messages aren't very interesting, no matter
     409                   how much some servers love to send them. */
     410                return;
     411        }
     412
     413        if (chat == NULL) {
     414                if (nick == NULL) {
     415                        imcb_log(ic, "System message from unknown groupchat %s: %s", from, body->text);
    391416                } else {
    392                         /* message.c uses the EXACT_JID option, so bud should
    393                            always be NULL here for bare JIDs. */
    394                         chat = jabber_chat_by_jid(ic, s);
    395                 }
    396 
    397                 if (nick == NULL) {
    398                         /* This is fine, the groupchat itself isn't in jd->buddies. */
    399                         if (chat) {
    400                                 imcb_chat_log(chat, "From conference server: %s", body->text);
    401                         } else {
    402                                 imcb_log(ic, "System message from unknown groupchat %s: %s", s, body->text);
    403                         }
    404                 } else {
    405                         /* This can happen too, at least when receiving a backlog when
    406                            just joining a channel. */
    407                         if (chat) {
    408                                 imcb_chat_log(chat, "Message from unknown participant %s: %s", nick, body->text);
    409                         } else {
    410                                 imcb_log(ic, "Groupchat message from unknown JID %s: %s", s, body->text);
    411                         }
     417                        imcb_log(ic, "Groupchat message from unknown JID %s: %s", from, body->text);
    412418                }
    413419
    414420                return;
    415         } else if (chat == NULL) {
    416                 /* How could this happen?? We could do kill( self, 11 )
    417                    now or just wait for the OS to do it. :-) */
     421        } else if (chat != NULL && bud == NULL && nick == NULL) {
     422                imcb_chat_log(chat, "From conference server: %s", body->text);
    418423                return;
    419         }
    420         if (body && body->text_len > 0) {
    421                 s = (bud->ext_jid) ? strchr(bud->ext_jid, '/') : NULL;
    422                 if (s) {
    423                         *s = 0;
    424                 }
    425                 imcb_chat_msg(chat, bud->ext_jid, body->text, 0, jabber_get_timestamp(node));
    426                 if (s) {
    427                         *s = '/';
    428                 }
    429         }
    430 }
     424        } else if (jc && jc->flags & JCFLAG_MESSAGE_SENT && bud == jc->me) {
     425                /* exclude self-messages since they would get filtered out
     426                 * but not the ones in the backlog */
     427                return;
     428        }
     429
     430        if (bud && jc && bud != jc->me) {
     431                bare_jid = jabber_get_bare_jid(bud->ext_jid ? bud->ext_jid : bud->full_jid);
     432                final_from = bare_jid;
     433        } else {
     434                final_from = nick;
     435        }
     436
     437        imcb_chat_msg(chat, final_from, body->text, 0, jabber_get_timestamp(node));
     438
     439        g_free(bare_jid);
     440}

  • protocols/jabber/hipchat.c

    r5014380 rb8c336b  
    2727{
    2828        struct jabber_data *jd = ic->proto_data;
    29         char *sep, *jid;
     29        char *sep, *jid, *muc_host;
    3030
    3131        jid = xt_find_attr(node, "jid");
     32        muc_host = xt_find_attr(node, "muc_host");
    3233
    3334        sep = strchr(jid, '/');
    … …  
    4849        if (!jabber_get_roster(ic) ||
    4950            !jabber_iq_disco_server(ic) ||
    50             !jabber_get_hipchat_profile(ic)) {
     51            !jabber_get_hipchat_profile(ic) ||
     52            !jabber_iq_disco_muc(ic, muc_host)) {
    5153                return XT_ABORT;
    5254        }
    … …  
    9294
    9395}
     96
     97int jabber_iq_disco_muc(struct im_connection *ic, char *muc_server)
     98{
     99        struct xt_node *node;
     100        int st;
     101
     102        imcb_log(ic, "Fetching MUC list");
     103
     104        node = xt_new_node("query", NULL, NULL);
     105        xt_add_attr(node, "xmlns", XMLNS_DISCO_ITEMS);
     106        node = jabber_make_packet("iq", "get", muc_server, node);
     107
     108        jabber_cache_add(ic, node, jabber_parse_muc_list);
     109        st = jabber_write_packet(ic, node);
     110
     111        return st;
     112}
     113
     114xt_status jabber_parse_muc_list(struct im_connection *ic, struct xt_node *node, struct xt_node *orig)
     115{
     116        struct xt_node *query, *c;
     117
     118        if (!(query = xt_find_node(node->children, "query"))) {
     119                imcb_log(ic, "Warning: Received NULL MUC list packet");
     120                return XT_HANDLED;
     121        }
     122
     123        c = query->children;
     124        while ((c = xt_find_node(c, "item"))) {
     125                struct xt_node *c2;
     126                char *topic = NULL;
     127                char *jid = xt_find_attr(c, "jid");
     128                char *name = xt_find_attr(c, "name");
     129
     130                imcb_log(ic, "Debug: adding MUC to channel list: %s - '%s'", jid, name);
     131
     132                if ((c2 = xt_find_node_by_attr(c->children, "x", "xmlns", XMLNS_HIPCHAT_MUC)) &&
     133                    (c2 = xt_find_node(c2->children, "topic"))) {
     134                        topic = c2->text;
     135                }
     136
     137                imcb_chat_placeholder_new(ic, jid, name, topic);
     138                c = c->next;
     139        }
     140        return XT_HANDLED;
     141
     142}

  • protocols/jabber/jabber.h

    r5014380 rb8c336b  
    239239#define XMLNS_HIPCHAT         "http://hipchat.com"
    240240#define XMLNS_HIPCHAT_PROFILE "http://hipchat.com/protocol/profile"
     241#define XMLNS_HIPCHAT_MUC     "http://hipchat.com/protocol/muc#room"
    241242
    242243/* jabber.c */
    … …  
    249250int jabber_get_roster(struct im_connection *ic);
    250251int jabber_get_vcard(struct im_connection *ic, char *bare_jid);
     252int jabber_iq_disco_muc(struct im_connection *ic, char *muc_server);
    251253int jabber_add_to_roster(struct im_connection *ic, const char *handle, const char *name, const char *group);
    252254int jabber_remove_from_roster(struct im_connection *ic, char *handle);
    … …  
    312314void jabber_error_free(struct jabber_error *err);
    313315gboolean jabber_set_me(struct im_connection *ic, const char *me);
     316char *jabber_get_bare_jid(char *jid);
    314317
    315318extern const struct jabber_away_state jabber_away_state_list[];
    … …  
    351354xt_status jabber_parse_hipchat_profile(struct im_connection *ic, struct xt_node *node, struct xt_node *orig);
    352355xt_status hipchat_handle_success(struct im_connection *ic, struct xt_node *node);
     356xt_status jabber_parse_muc_list(struct im_connection *ic, struct xt_node *node, struct xt_node *orig);
    353357
    354358#endif

  • protocols/jabber/jabber_util.c

    r5014380 rb8c336b  
    820820        return TRUE;
    821821}
     822
     823/* Returns new reference! g_free() afterwards. */
     824char *jabber_get_bare_jid(char *jid)
     825{
     826        char *s = NULL;
     827
     828        if (jid == NULL) {
     829                return NULL;
     830        }
     831
     832        if ((s = strchr(jid, '/'))) {
     833                return g_strndup(jid, s - jid);
     834        } else {
     835                return g_strdup(jid);
     836        }
     837}
Note: See TracChangeset for help on using the changeset viewer.