← Back to branch summary

~ted/pidgin/12_sounds_and_timers.patch

« back to all changes in this revision

Viewing changes to libpurple/protocols/qq/group_info.c

  • Committer: Bazaar Package Importer
  • Date: 2008-10-13 20:39:58 UTC
  • Revision ID: jamesw@ubuntu.com-20081013203958-qbn4ctthrb8bjsco
Tags: upstream-ubuntu-2.4.3
ImportĀ upstreamĀ versionĀ 2.4.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
libpurple/protocols/qq/group_info.c
43
43
{
44
44
        g_return_val_if_fail(member != NULL, FALSE);
45
45
        return (member->nickname == NULL) ||
46
 
            (time(NULL) - member->last_refresh) > QQ_GROUP_CHAT_REFRESH_NICKNAME_INTERNAL;
 
46
                (time(NULL) - member->last_refresh) > QQ_GROUP_CHAT_REFRESH_NICKNAME_INTERNAL;
47
47
}
48
48
 
49
49
/* this is done when we receive the reply to get_online_members sub_cmd
65
65
/* send packet to get detailed information of one group */
66
66
void qq_send_cmd_group_get_group_info(PurpleConnection *gc, qq_group *group)
67
67
{
68
 
        guint8 *raw_data, *cursor;
69
 
        gint bytes, data_len;
 
68
        guint8 raw_data[16] = {0};
 
69
        gint bytes = 0;
70
70
 
71
71
        g_return_if_fail(group != NULL);
72
72
 
73
 
        data_len = 5;
74
 
        raw_data = g_newa(guint8, data_len);
75
 
        cursor = raw_data;
76
 
 
77
 
        bytes = 0;
78
 
        bytes += create_packet_b(raw_data, &cursor, QQ_GROUP_CMD_GET_GROUP_INFO);
79
 
        bytes += create_packet_dw(raw_data, &cursor, group->internal_group_id);
80
 
 
81
 
        if (bytes != data_len)
82
 
                purple_debug(PURPLE_DEBUG_ERROR, "QQ",
83
 
                           "Fail create packet for %s\n", qq_group_cmd_get_desc(QQ_GROUP_CMD_GET_GROUP_INFO));
84
 
        else
85
 
                qq_send_group_cmd(gc, group, raw_data, data_len);
 
73
        bytes += qq_put8(raw_data + bytes, QQ_GROUP_CMD_GET_GROUP_INFO);
 
74
        bytes += qq_put32(raw_data + bytes, group->internal_group_id);
 
75
 
 
76
        qq_send_group_cmd(gc, group, raw_data, bytes);
86
77
}
87
78
 
88
79
/* send packet to get online group member, called by keep_alive */
89
80
void qq_send_cmd_group_get_online_members(PurpleConnection *gc, qq_group *group)
90
81
{
91
 
        guint8 *raw_data, *cursor;
92
 
        gint bytes, data_len;
 
82
        guint8 raw_data[16] = {0};
 
83
        gint bytes = 0;
93
84
 
94
85
        g_return_if_fail(group != NULL);
95
86
 
96
87
        /* only get online members when conversation window is on */
97
88
        if (NULL == purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,group->group_name_utf8, purple_connection_get_account(gc))) {
98
89
                purple_debug(PURPLE_DEBUG_WARNING, "QQ",
99
 
                           "Conv windows for \"%s\" is not on, do not get online members\n", group->group_name_utf8);
 
90
                                "Conv windows for \"%s\" is not on, do not get online members\n", group->group_name_utf8);
100
91
                return;
101
92
        }
102
93
 
103
 
        data_len = 5;
104
 
        raw_data = g_newa(guint8, data_len);
105
 
        cursor = raw_data;
106
 
 
107
 
        bytes = 0;
108
 
        bytes += create_packet_b(raw_data, &cursor, QQ_GROUP_CMD_GET_ONLINE_MEMBER);
109
 
        bytes += create_packet_dw(raw_data, &cursor, group->internal_group_id);
110
 
 
111
 
        if (bytes != data_len)
112
 
                purple_debug(PURPLE_DEBUG_ERROR, "QQ",
113
 
                           "Fail create packet for %s\n", qq_group_cmd_get_desc(QQ_GROUP_CMD_GET_ONLINE_MEMBER));
114
 
        else
115
 
                qq_send_group_cmd(gc, group, raw_data, data_len);
 
94
        bytes += qq_put8(raw_data + bytes, QQ_GROUP_CMD_GET_ONLINE_MEMBER);
 
95
        bytes += qq_put32(raw_data + bytes, group->internal_group_id);
 
96
 
 
97
        qq_send_group_cmd(gc, group, raw_data, bytes);
116
98
}
117
99
 
118
100
/* send packet to get info for each group member */
119
101
void qq_send_cmd_group_get_members_info(PurpleConnection *gc, qq_group *group)
120
102
{
121
 
        guint8 *raw_data, *cursor;
122
 
        gint bytes, data_len, i;
 
103
        guint8 *raw_data;
 
104
        gint bytes, num, data_len;
123
105
        GList *list;
124
106
        qq_buddy *member;
125
107
 
126
108
        g_return_if_fail(group != NULL);
127
 
        for (i = 0, list = group->members; list != NULL; list = list->next) {
 
109
        for (num = 0, list = group->members; list != NULL; list = list->next) {
128
110
                member = (qq_buddy *) list->data;
129
111
                if (_is_group_member_need_update_info(member))
130
 
                        i++;
 
112
                        num++;
131
113
        }
132
114
 
133
 
        if (i <= 0) {
 
115
        if (num <= 0) {
134
116
                purple_debug(PURPLE_DEBUG_INFO, "QQ", "No group member needs to to update info now.\n");
135
117
                return;
136
118
        }
137
119
 
138
 
        data_len = 5 + 4 * i;
 
120
        data_len = 5 + 4 * num;
139
121
        raw_data = g_newa(guint8, data_len);
140
 
        cursor = raw_data;
141
122
 
142
123
        bytes = 0;
143
 
        bytes += create_packet_b(raw_data, &cursor, QQ_GROUP_CMD_GET_MEMBER_INFO);
144
 
        bytes += create_packet_dw(raw_data, &cursor, group->internal_group_id);
 
124
        bytes += qq_put8(raw_data + bytes, QQ_GROUP_CMD_GET_MEMBER_INFO);
 
125
        bytes += qq_put32(raw_data + bytes, group->internal_group_id);
145
126
 
146
127
        list = group->members;
147
128
        while (list != NULL) {
148
129
                member = (qq_buddy *) list->data;
149
130
                if (_is_group_member_need_update_info(member))
150
 
                        bytes += create_packet_dw(raw_data, &cursor, member->uid);
 
131
                        bytes += qq_put32(raw_data + bytes, member->uid);
151
132
                list = list->next;
152
133
        }
153
134
 
154
 
        if (bytes != data_len)
 
135
        if (bytes != data_len) {
155
136
                purple_debug(PURPLE_DEBUG_ERROR, "QQ",
156
 
                           "Fail create packet for %s\n", qq_group_cmd_get_desc(QQ_GROUP_CMD_GET_MEMBER_INFO));
157
 
        else
158
 
                qq_send_group_cmd(gc, group, raw_data, data_len);
 
137
                                "Fail create packet for %s\n", qq_group_cmd_get_desc(QQ_GROUP_CMD_GET_MEMBER_INFO));
 
138
                return;
 
139
        }
 
140
 
 
141
        qq_send_group_cmd(gc, group, raw_data, bytes);
159
142
}
160
143
 
161
 
void qq_process_group_cmd_get_group_info(guint8 *data, guint8 **cursor, gint len, PurpleConnection *gc)
 
144
/**
 
145
 * @brief å¤„ē†ē¾¤äæ”ęÆ.当前ē¾¤äæ”ęÆēš„处ē†čæ˜äøå®Œå–„,ē”±äŗŽē‰ˆęœ¬ēš„äøåŒåÆ¼č‡“åč®®ēš„č§£čÆ»ęœ‰å·®å¼‚.
 
146
 */
 
147
void qq_process_group_cmd_get_group_info(guint8 *data, gint len, PurpleConnection *gc)
162
148
{
163
149
        qq_group *group;
164
150
        qq_buddy *member;
168
154
        guint16 unknown, max_members;
169
155
        guint32 member_uid, internal_group_id, external_group_id;
170
156
        GSList *pending_id;
171
 
        gint pascal_len, i;
172
157
        guint32 unknown4;
173
158
        guint8 unknown1;
 
159
        gint bytes, num;
174
160
 
175
161
        g_return_if_fail(data != NULL && len > 0);
176
162
        qd = (qq_data *) gc->proto_data;
177
163
 
178
 
        read_packet_dw(data, cursor, len, &(internal_group_id));
179
 
        g_return_if_fail(internal_group_id > 0);
180
 
        read_packet_dw(data, cursor, len, &(external_group_id));
181
 
        g_return_if_fail(internal_group_id > 0);
 
164
        bytes = 0;
 
165
        bytes += qq_get32(&(internal_group_id), data + bytes);
 
166
        g_return_if_fail(internal_group_id > 0);
 
167
 
 
168
        bytes += qq_get32(&(external_group_id), data + bytes);
 
169
        g_return_if_fail(external_group_id > 0);
182
170
 
183
171
        pending_id = qq_get_pending_id(qd->adding_groups_from_server, internal_group_id);
184
172
        if (pending_id != NULL) {
189
177
        group = qq_group_find_by_id(gc, internal_group_id, QQ_INTERNAL_ID);
190
178
        g_return_if_fail(group != NULL);
191
179
 
192
 
        read_packet_b(data, cursor, len, &(group->group_type));
193
 
        read_packet_dw(data, cursor, len, &unknown4);   /* unknown 4 bytes */
194
 
        read_packet_dw(data, cursor, len, &(group->creator_uid));
195
 
        read_packet_b(data, cursor, len, &(group->auth_type));
196
 
        read_packet_dw(data, cursor, len, &unknown4);   /* oldCategory */
197
 
        read_packet_w(data, cursor, len, &unknown);     
198
 
        read_packet_dw(data, cursor, len, &(group->group_category));
199
 
        read_packet_w(data, cursor, len, &max_members);
200
 
        read_packet_b(data, cursor, len, &unknown1);
201
 
        read_packet_dw(data, cursor, len, &(unknown4)); /* versionID */
202
 
 
203
 
        pascal_len = convert_as_pascal_string(*cursor, &(group->group_name_utf8), QQ_CHARSET_DEFAULT);
204
 
        *cursor += pascal_len;
205
 
        read_packet_w(data, cursor, len, &(unknown));   /* 0x0000 */
206
 
        pascal_len = convert_as_pascal_string(*cursor, &(group->notice_utf8), QQ_CHARSET_DEFAULT);
207
 
        *cursor += pascal_len;
208
 
        pascal_len = convert_as_pascal_string(*cursor, &(group->group_desc_utf8), QQ_CHARSET_DEFAULT);
209
 
        *cursor += pascal_len;
210
 
 
211
 
        i = 0;
 
180
        bytes += qq_get8(&(group->group_type), data + bytes);
 
181
        bytes += qq_get32(&unknown4, data + bytes);     /* unknown 4 bytes */
 
182
        bytes += qq_get32(&(group->creator_uid), data + bytes);
 
183
        bytes += qq_get8(&(group->auth_type), data + bytes);
 
184
        bytes += qq_get32(&unknown4, data + bytes);     /* oldCategory */
 
185
        bytes += qq_get16(&unknown, data + bytes);      
 
186
        bytes += qq_get32(&(group->group_category), data + bytes);
 
187
        bytes += qq_get16(&max_members, data + bytes);
 
188
        bytes += qq_get8(&unknown1, data + bytes);
 
189
        /* XXX
 
190
         * the following, while Eva:
 
191
         * 4(unk), 4(verID), 1(nameLen), nameLen(qunNameContent), 1(0x00),
 
192
         * 2(qunNoticeLen), qunNoticeLen(qunNoticeContent, 1(qunDescLen),
 
193
         * qunDestLen(qunDestcontent)) */
 
194
        bytes += qq_get8(&unknown1, data + bytes);
 
195
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "type=%u creatorid=%u category=%u\n",
 
196
                        group->group_type, group->creator_uid, group->group_category);
 
197
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "maxmembers=%u", max_members); 
 
198
        
 
199
        /* strlen + <str content> */
 
200
        bytes += convert_as_pascal_string(data + bytes, &(group->group_name_utf8), QQ_CHARSET_DEFAULT);
 
201
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "group \"%s\"\n", group->group_name_utf8); 
 
202
        bytes += qq_get16(&unknown, data + bytes);      /* 0x0000 */
 
203
        bytes += convert_as_pascal_string(data + bytes, &(group->notice_utf8), QQ_CHARSET_DEFAULT);
 
204
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "notice \"%s\"\n", group->notice_utf8); 
 
205
        bytes += convert_as_pascal_string(data + bytes, &(group->group_desc_utf8), QQ_CHARSET_DEFAULT);
 
206
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "group_desc \"%s\"\n", group->group_desc_utf8); 
 
207
 
 
208
        num = 0;
212
209
        /* now comes the member list separated by 0x00 */
213
 
        while (*cursor < data + len) {
214
 
                read_packet_dw(data, cursor, len, &member_uid);
215
 
                i++;
216
 
                read_packet_b(data, cursor, len, &organization);
217
 
                read_packet_b(data, cursor, len, &role);
 
210
        while (bytes < len) {
 
211
                bytes += qq_get32(&member_uid, data + bytes);
 
212
                num++;
 
213
                bytes += qq_get8(&organization, data + bytes);
 
214
                bytes += qq_get8(&role, data + bytes);
218
215
 
219
216
                if(organization != 0 || role != 0) {
220
217
                        purple_debug(PURPLE_DEBUG_INFO, "QQ", "group member %d: organization=%d, role=%d\n", member_uid, organization, role);
223
220
                if (member != NULL)
224
221
                        member->role = role;
225
222
        }
226
 
        if(*cursor > (data + len)) {
227
 
                         purple_debug(PURPLE_DEBUG_ERROR, "QQ", "group_cmd_get_group_info: Dangerous error! maybe protocol changed, notify me!");
228
 
        }
 
223
        if(bytes > len) {
 
224
                purple_debug(PURPLE_DEBUG_ERROR, "QQ", "group_cmd_get_group_info: Dangerous error! maybe protocol changed, notify me!");
 
225
        }
229
226
 
230
 
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "group \"%s\" has %d members\n", group->group_name_utf8, i);
 
227
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "group \"%s\" has %d members\n", group->group_name_utf8, num);
231
228
 
232
229
        if (group->creator_uid == qd->uid)
233
230
                group->my_status = QQ_GROUP_MEMBER_STATUS_IS_ADMIN;
237
234
        purple_conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, 
238
235
                        group->group_name_utf8, purple_connection_get_account(gc));
239
236
        if(NULL == purple_conv) {
240
 
                purple_debug(PURPLE_DEBUG_WARNING, "QQ",
241
 
                           "Conv windows for \"%s\" is not on, do not set topic\n", group->group_name_utf8);
 
237
                purple_debug(PURPLE_DEBUG_WARNING, "QQ",
 
238
                                "Conv windows for \"%s\" is not on, do not set topic\n", group->group_name_utf8);
242
239
        }
243
240
        else {
244
241
                purple_conv_chat_set_topic(PURPLE_CONV_CHAT(purple_conv), NULL, group->notice_utf8);
245
242
        }
246
243
}
247
244
 
248
 
void qq_process_group_cmd_get_online_members(guint8 *data, guint8 **cursor, gint len, PurpleConnection *gc)
 
245
void qq_process_group_cmd_get_online_members(guint8 *data, gint len, PurpleConnection *gc)
249
246
{
250
247
        guint32 internal_group_id, member_uid;
251
248
        guint8 unknown;
252
 
        gint bytes, i;
 
249
        gint bytes, num;
253
250
        qq_group *group;
254
251
        qq_buddy *member;
255
252
 
256
253
        g_return_if_fail(data != NULL && len > 0);
257
254
 
258
 
        if (data + len - *cursor < 4) {
 
255
        if (len <= 3) {
259
256
                purple_debug(PURPLE_DEBUG_ERROR, "QQ", "Invalid group online member reply, discard it!\n");
260
257
                return;
261
258
        }
262
259
 
263
260
        bytes = 0;
264
 
        i = 0;
265
 
        bytes += read_packet_dw(data, cursor, len, &internal_group_id);
266
 
        bytes += read_packet_b(data, cursor, len, &unknown);    /* 0x3c ?? */
 
261
        bytes += qq_get32(&internal_group_id, data + bytes);
 
262
        bytes += qq_get8(&unknown, data + bytes);       /* 0x3c ?? */
267
263
        g_return_if_fail(internal_group_id > 0);
268
264
 
269
265
        group = qq_group_find_by_id(gc, internal_group_id, QQ_INTERNAL_ID);
275
271
 
276
272
        /* set all offline first, then update those online */
277
273
        _qq_group_set_members_all_offline(group);
278
 
        while (*cursor < data + len) {
279
 
                bytes += read_packet_dw(data, cursor, len, &member_uid);
280
 
                i++;
 
274
        num = 0;
 
275
        while (bytes < len) {
 
276
                bytes += qq_get32(&member_uid, data + bytes);
 
277
                num++;
281
278
                member = qq_group_find_or_add_member(gc, group, member_uid);
282
279
                if (member != NULL)
283
280
                        member->status = QQ_BUDDY_ONLINE_NORMAL;
284
281
        }
285
 
        if(*cursor > (data + len)) {
286
 
                         purple_debug(PURPLE_DEBUG_ERROR, "QQ", 
287
 
                                         "group_cmd_get_online_members: Dangerous error! maybe protocol changed, notify developers!");
288
 
        }
 
282
        if(bytes > len) {
 
283
                purple_debug(PURPLE_DEBUG_ERROR, "QQ", 
 
284
                                "group_cmd_get_online_members: Dangerous error! maybe protocol changed, notify developers!");
 
285
        }
289
286
 
290
 
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "Group \"%s\" has %d online members\n", group->group_name_utf8, i);
 
287
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "Group \"%s\" has %d online members\n", group->group_name_utf8, num);
291
288
}
292
289
 
293
290
/* process the reply to get_members_info packet */
294
 
void qq_process_group_cmd_get_members_info(guint8 *data, guint8 **cursor, gint len, PurpleConnection *gc)
 
291
void qq_process_group_cmd_get_members_info(guint8 *data, gint len, PurpleConnection *gc)
295
292
{
 
293
        gint bytes;
 
294
        gint num;
296
295
        guint32 internal_group_id, member_uid;
297
296
        guint16 unknown;
298
 
        gint pascal_len, i;
299
297
        qq_group *group;
300
298
        qq_buddy *member;
301
299
 
302
300
        g_return_if_fail(data != NULL && len > 0);
303
301
 
304
 
        read_packet_dw(data, cursor, len, &internal_group_id);
 
302
        bytes = 0;
 
303
        bytes += qq_get32(&internal_group_id, data + bytes);
305
304
        g_return_if_fail(internal_group_id > 0);
306
305
 
307
306
        group = qq_group_find_by_id(gc, internal_group_id, QQ_INTERNAL_ID);
308
307
        g_return_if_fail(group != NULL);
309
308
 
310
 
        i = 0;
 
309
        num = 0;
311
310
        /* now starts the member info, as get buddy list reply */
312
 
        while (*cursor < data + len) {
313
 
                read_packet_dw(data, cursor, len, &member_uid);
 
311
        while (bytes < len) {
 
312
                bytes += qq_get32(&member_uid, data + bytes);
314
313
                g_return_if_fail(member_uid > 0);
315
314
                member = qq_group_find_member_by_uid(group, member_uid);
316
315
                g_return_if_fail(member != NULL);
317
316
 
318
 
                i++;
319
 
                read_packet_w(data, cursor, len, &(member->face));
320
 
                read_packet_b(data, cursor, len, &(member->age));
321
 
                read_packet_b(data, cursor, len, &(member->gender));
322
 
                pascal_len = convert_as_pascal_string(*cursor, &(member->nickname), QQ_CHARSET_DEFAULT);
323
 
                *cursor += pascal_len;
324
 
                read_packet_w(data, cursor, len, &unknown);
325
 
                read_packet_b(data, cursor, len, &(member->flag1));
326
 
                read_packet_b(data, cursor, len, &(member->comm_flag));
 
317
                num++;
 
318
                bytes += qq_get16(&(member->face), data + bytes);
 
319
                bytes += qq_get8(&(member->age), data + bytes);
 
320
                bytes += qq_get8(&(member->gender), data + bytes);
 
321
                bytes += convert_as_pascal_string(data + bytes, &(member->nickname), QQ_CHARSET_DEFAULT);
 
322
                bytes += qq_get16(&unknown, data + bytes);
 
323
                bytes += qq_get8(&(member->flag1), data + bytes);
 
324
                bytes += qq_get8(&(member->comm_flag), data + bytes);
327
325
 
328
326
                member->last_refresh = time(NULL);
329
327
        }
330
 
        if(*cursor > (data + len)) {
331
 
                         purple_debug(PURPLE_DEBUG_ERROR, "QQ", 
332
 
                                         "group_cmd_get_members_info: Dangerous error! maybe protocol changed, notify developers!");
333
 
        }
334
 
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "Group \"%s\" obtained %d member info\n", group->group_name_utf8, i);
 
328
        if(bytes > len) {
 
329
                purple_debug(PURPLE_DEBUG_ERROR, "QQ", 
 
330
                                "group_cmd_get_members_info: Dangerous error! maybe protocol changed, notify developers!");
 
331
        }
 
332
        purple_debug(PURPLE_DEBUG_INFO, "QQ", "Group \"%s\" obtained %d member info\n", group->group_name_utf8, num);
335
333
}