14192
|
1 /*
|
|
2 * gaim - Jabber Protocol Plugin
|
|
3 *
|
|
4 * Copyright (C) 2003, Nathan Walp <faceprint@faceprint.com>
|
|
5 *
|
|
6 * This program is free software; you can redistribute it and/or modify
|
|
7 * it under the terms of the GNU General Public License as published by
|
|
8 * the Free Software Foundation; either version 2 of the License, or
|
|
9 * (at your option) any later version.
|
|
10 *
|
|
11 * This program is distributed in the hope that it will be useful,
|
|
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
14 * GNU General Public License for more details.
|
|
15 *
|
|
16 * You should have received a copy of the GNU General Public License
|
|
17 * along with this program; if not, write to the Free Software
|
|
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
19 *
|
|
20 */
|
|
21 #include "internal.h"
|
|
22 #include "cipher.h"
|
|
23 #include "debug.h"
|
|
24 #include "imgstore.h"
|
|
25 #include "prpl.h"
|
|
26 #include "notify.h"
|
|
27 #include "request.h"
|
|
28 #include "util.h"
|
|
29 #include "xmlnode.h"
|
|
30
|
|
31 #include "buddy.h"
|
|
32 #include "chat.h"
|
|
33 #include "jabber.h"
|
|
34 #include "iq.h"
|
|
35 #include "presence.h"
|
|
36 #include "xdata.h"
|
|
37
|
|
38 typedef struct {
|
|
39 long idle_seconds;
|
|
40 } JabberBuddyInfoResource;
|
|
41
|
|
42 typedef struct {
|
|
43 JabberStream *js;
|
|
44 JabberBuddy *jb;
|
|
45 char *jid;
|
|
46 GSList *ids;
|
|
47 GHashTable *resources;
|
|
48 int timeout_handle;
|
|
49 char *vcard_text;
|
|
50 GSList *vcard_imgids;
|
|
51 } JabberBuddyInfo;
|
|
52
|
|
53 void jabber_buddy_free(JabberBuddy *jb)
|
|
54 {
|
|
55 g_return_if_fail(jb != NULL);
|
|
56
|
|
57 if(jb->error_msg)
|
|
58 g_free(jb->error_msg);
|
|
59 while(jb->resources)
|
|
60 jabber_buddy_resource_free(jb->resources->data);
|
|
61
|
|
62 g_free(jb);
|
|
63 }
|
|
64
|
|
65 JabberBuddy *jabber_buddy_find(JabberStream *js, const char *name,
|
|
66 gboolean create)
|
|
67 {
|
|
68 JabberBuddy *jb;
|
|
69 const char *realname;
|
|
70
|
|
71 if(!(realname = jabber_normalize(js->gc->account, name)))
|
|
72 return NULL;
|
|
73
|
|
74 jb = g_hash_table_lookup(js->buddies, realname);
|
|
75
|
|
76 if(!jb && create) {
|
|
77 jb = g_new0(JabberBuddy, 1);
|
|
78 g_hash_table_insert(js->buddies, g_strdup(realname), jb);
|
|
79 }
|
|
80
|
|
81 return jb;
|
|
82 }
|
|
83
|
|
84
|
|
85 JabberBuddyResource *jabber_buddy_find_resource(JabberBuddy *jb,
|
|
86 const char *resource)
|
|
87 {
|
|
88 JabberBuddyResource *jbr = NULL;
|
|
89 GList *l;
|
|
90
|
|
91 if(!jb)
|
|
92 return NULL;
|
|
93
|
|
94 for(l = jb->resources; l; l = l->next)
|
|
95 {
|
|
96 if(!jbr && !resource) {
|
|
97 jbr = l->data;
|
|
98 } else if(!resource) {
|
|
99 if(((JabberBuddyResource *)l->data)->priority >= jbr->priority)
|
|
100 jbr = l->data;
|
|
101 } else if(((JabberBuddyResource *)l->data)->name) {
|
|
102 if(!strcmp(((JabberBuddyResource *)l->data)->name, resource)) {
|
|
103 jbr = l->data;
|
|
104 break;
|
|
105 }
|
|
106 }
|
|
107 }
|
|
108
|
|
109 return jbr;
|
|
110 }
|
|
111
|
|
112 JabberBuddyResource *jabber_buddy_track_resource(JabberBuddy *jb, const char *resource,
|
|
113 int priority, JabberBuddyState state, const char *status)
|
|
114 {
|
|
115 JabberBuddyResource *jbr = jabber_buddy_find_resource(jb, resource);
|
|
116
|
|
117 if(!jbr) {
|
|
118 jbr = g_new0(JabberBuddyResource, 1);
|
|
119 jbr->jb = jb;
|
|
120 jbr->name = g_strdup(resource);
|
|
121 jbr->capabilities = JABBER_CAP_XHTML;
|
|
122 jb->resources = g_list_append(jb->resources, jbr);
|
|
123 }
|
|
124 jbr->priority = priority;
|
|
125 jbr->state = state;
|
|
126 if(jbr->status)
|
|
127 g_free(jbr->status);
|
|
128 if (status)
|
|
129 jbr->status = g_markup_escape_text(status, -1);
|
|
130 else
|
|
131 jbr->status = NULL;
|
|
132
|
|
133 return jbr;
|
|
134 }
|
|
135
|
|
136 void jabber_buddy_resource_free(JabberBuddyResource *jbr)
|
|
137 {
|
|
138 g_return_if_fail(jbr != NULL);
|
|
139
|
|
140 jbr->jb->resources = g_list_remove(jbr->jb->resources, jbr);
|
|
141
|
|
142 g_free(jbr->name);
|
|
143 g_free(jbr->status);
|
|
144 g_free(jbr->thread_id);
|
|
145 g_free(jbr->client.name);
|
|
146 g_free(jbr->client.version);
|
|
147 g_free(jbr->client.os);
|
|
148 g_free(jbr);
|
|
149 }
|
|
150
|
|
151 void jabber_buddy_remove_resource(JabberBuddy *jb, const char *resource)
|
|
152 {
|
|
153 JabberBuddyResource *jbr = jabber_buddy_find_resource(jb, resource);
|
|
154
|
|
155 if(!jbr)
|
|
156 return;
|
|
157
|
|
158 jabber_buddy_resource_free(jbr);
|
|
159 }
|
|
160
|
|
161 const char *jabber_buddy_get_status_msg(JabberBuddy *jb)
|
|
162 {
|
|
163 JabberBuddyResource *jbr;
|
|
164
|
|
165 if(!jb)
|
|
166 return NULL;
|
|
167
|
|
168 jbr = jabber_buddy_find_resource(jb, NULL);
|
|
169
|
|
170 if(!jbr)
|
|
171 return NULL;
|
|
172
|
|
173 return jbr->status;
|
|
174 }
|
|
175
|
|
176 /*******
|
|
177 * This is the old vCard stuff taken from the old prpl. vCards, by definition
|
|
178 * are a temporary thing until jabber can get its act together and come up
|
|
179 * with a format for user information, hence the namespace of 'vcard-temp'
|
|
180 *
|
|
181 * Since I don't feel like putting that much work into something that's
|
|
182 * _supposed_ to go away, i'm going to just copy the kludgy old code here,
|
|
183 * and make it purdy when jabber comes up with a standards-track JEP to
|
|
184 * replace vcard-temp
|
|
185 * --Nathan
|
|
186 *******/
|
|
187
|
|
188 /*---------------------------------------*/
|
|
189 /* Jabber "set info" (vCard) support */
|
|
190 /*---------------------------------------*/
|
|
191
|
|
192 /*
|
|
193 * V-Card format:
|
|
194 *
|
|
195 * <vCard prodid='' version='' xmlns=''>
|
|
196 * <FN></FN>
|
|
197 * <N>
|
|
198 * <FAMILY/>
|
|
199 * <GIVEN/>
|
|
200 * </N>
|
|
201 * <NICKNAME/>
|
|
202 * <URL/>
|
|
203 * <ADR>
|
|
204 * <STREET/>
|
|
205 * <EXTADD/>
|
|
206 * <LOCALITY/>
|
|
207 * <REGION/>
|
|
208 * <PCODE/>
|
|
209 * <COUNTRY/>
|
|
210 * </ADR>
|
|
211 * <TEL/>
|
|
212 * <EMAIL/>
|
|
213 * <ORG>
|
|
214 * <ORGNAME/>
|
|
215 * <ORGUNIT/>
|
|
216 * </ORG>
|
|
217 * <TITLE/>
|
|
218 * <ROLE/>
|
|
219 * <DESC/>
|
|
220 * <BDAY/>
|
|
221 * </vCard>
|
|
222 *
|
|
223 * See also:
|
|
224 *
|
|
225 * http://docs.jabber.org/proto/html/vcard-temp.html
|
|
226 * http://www.vcard-xml.org/dtd/vCard-XML-v2-20010520.dtd
|
|
227 */
|
|
228
|
|
229 /*
|
|
230 * Cross-reference user-friendly V-Card entry labels to vCard XML tags
|
|
231 * and attributes.
|
|
232 *
|
|
233 * Order is (or should be) unimportant. For example: we have no way of
|
|
234 * knowing in what order real data will arrive.
|
|
235 *
|
|
236 * Format: Label, Pre-set text, "visible" flag, "editable" flag, XML tag
|
|
237 * name, XML tag's parent tag "path" (relative to vCard node).
|
|
238 *
|
|
239 * List is terminated by a NULL label pointer.
|
|
240 *
|
|
241 * Entries with no label text, but with XML tag and parent tag
|
|
242 * entries, are used by V-Card XML construction routines to
|
|
243 * "automagically" construct the appropriate XML node tree.
|
|
244 *
|
|
245 * Thoughts on future direction/expansion
|
|
246 *
|
|
247 * This is a "simple" vCard.
|
|
248 *
|
|
249 * It is possible for nodes other than the "vCard" node to have
|
|
250 * attributes. Should that prove necessary/desirable, add an
|
|
251 * "attributes" pointer to the vcard_template struct, create the
|
|
252 * necessary tag_attr structs, and add 'em to the vcard_dflt_data
|
|
253 * array.
|
|
254 *
|
|
255 * The above changes will (obviously) require changes to the vCard
|
|
256 * construction routines.
|
|
257 */
|
|
258
|
|
259 struct vcard_template {
|
|
260 char *label; /* label text pointer */
|
|
261 char *text; /* entry text pointer */
|
|
262 int visible; /* should entry field be "visible?" */
|
|
263 int editable; /* should entry field be editable? */
|
|
264 char *tag; /* tag text */
|
|
265 char *ptag; /* parent tag "path" text */
|
|
266 char *url; /* vCard display format if URL */
|
|
267 } vcard_template_data[] = {
|
|
268 {N_("Full Name"), NULL, TRUE, TRUE, "FN", NULL, NULL},
|
|
269 {N_("Family Name"), NULL, TRUE, TRUE, "FAMILY", "N", NULL},
|
|
270 {N_("Given Name"), NULL, TRUE, TRUE, "GIVEN", "N", NULL},
|
|
271 {N_("Nickname"), NULL, TRUE, TRUE, "NICKNAME", NULL, NULL},
|
|
272 {N_("URL"), NULL, TRUE, TRUE, "URL", NULL, "<A HREF=\"%s\">%s</A>"},
|
|
273 {N_("Street Address"), NULL, TRUE, TRUE, "STREET", "ADR", NULL},
|
|
274 {N_("Extended Address"), NULL, TRUE, TRUE, "EXTADD", "ADR", NULL},
|
|
275 {N_("Locality"), NULL, TRUE, TRUE, "LOCALITY", "ADR", NULL},
|
|
276 {N_("Region"), NULL, TRUE, TRUE, "REGION", "ADR", NULL},
|
|
277 {N_("Postal Code"), NULL, TRUE, TRUE, "PCODE", "ADR", NULL},
|
|
278 {N_("Country"), NULL, TRUE, TRUE, "CTRY", "ADR", NULL},
|
|
279 {N_("Telephone"), NULL, TRUE, TRUE, "NUMBER", "TEL", NULL},
|
|
280 {N_("E-Mail"), NULL, TRUE, TRUE, "USERID", "EMAIL", "<A HREF=\"mailto:%s\">%s</A>"},
|
|
281 {N_("Organization Name"), NULL, TRUE, TRUE, "ORGNAME", "ORG", NULL},
|
|
282 {N_("Organization Unit"), NULL, TRUE, TRUE, "ORGUNIT", "ORG", NULL},
|
|
283 {N_("Title"), NULL, TRUE, TRUE, "TITLE", NULL, NULL},
|
|
284 {N_("Role"), NULL, TRUE, TRUE, "ROLE", NULL, NULL},
|
|
285 {N_("Birthday"), NULL, TRUE, TRUE, "BDAY", NULL, NULL},
|
|
286 {N_("Description"), NULL, TRUE, TRUE, "DESC", NULL, NULL},
|
|
287 {"", NULL, TRUE, TRUE, "N", NULL, NULL},
|
|
288 {"", NULL, TRUE, TRUE, "ADR", NULL, NULL},
|
|
289 {"", NULL, TRUE, TRUE, "ORG", NULL, NULL},
|
|
290 {NULL, NULL, 0, 0, NULL, NULL, NULL}
|
|
291 };
|
|
292
|
|
293 /*
|
|
294 * The "vCard" tag's attribute list...
|
|
295 */
|
|
296 struct tag_attr {
|
|
297 char *attr;
|
|
298 char *value;
|
|
299 } vcard_tag_attr_list[] = {
|
|
300 {"prodid", "-//HandGen//NONSGML vGen v1.0//EN"},
|
|
301 {"version", "2.0", },
|
|
302 {"xmlns", "vcard-temp", },
|
|
303 {NULL, NULL},
|
|
304 };
|
|
305
|
|
306
|
|
307 /*
|
|
308 * Insert a tag node into an xmlnode tree, recursively inserting parent tag
|
|
309 * nodes as necessary
|
|
310 *
|
|
311 * Returns pointer to inserted node
|
|
312 *
|
|
313 * Note to hackers: this code is designed to be re-entrant (it's recursive--it
|
|
314 * calls itself), so don't put any "static"s in here!
|
|
315 */
|
|
316 static xmlnode *insert_tag_to_parent_tag(xmlnode *start, const char *parent_tag, const char *new_tag)
|
|
317 {
|
|
318 xmlnode *x = NULL;
|
|
319
|
|
320 /*
|
|
321 * If the parent tag wasn't specified, see if we can get it
|
|
322 * from the vCard template struct.
|
|
323 */
|
|
324 if(parent_tag == NULL) {
|
|
325 struct vcard_template *vc_tp = vcard_template_data;
|
|
326
|
|
327 while(vc_tp->label != NULL) {
|
|
328 if(strcmp(vc_tp->tag, new_tag) == 0) {
|
|
329 parent_tag = vc_tp->ptag;
|
|
330 break;
|
|
331 }
|
|
332 ++vc_tp;
|
|
333 }
|
|
334 }
|
|
335
|
|
336 /*
|
|
337 * If we have a parent tag...
|
|
338 */
|
|
339 if(parent_tag != NULL ) {
|
|
340 /*
|
|
341 * Try to get the parent node for a tag
|
|
342 */
|
|
343 if((x = xmlnode_get_child(start, parent_tag)) == NULL) {
|
|
344 /*
|
|
345 * Descend?
|
|
346 */
|
|
347 char *grand_parent = g_strdup(parent_tag);
|
|
348 char *parent;
|
|
349
|
|
350 if((parent = strrchr(grand_parent, '/')) != NULL) {
|
|
351 *(parent++) = '\0';
|
|
352 x = insert_tag_to_parent_tag(start, grand_parent, parent);
|
|
353 } else {
|
|
354 x = xmlnode_new_child(start, grand_parent);
|
|
355 }
|
|
356 g_free(grand_parent);
|
|
357 } else {
|
|
358 /*
|
|
359 * We found *something* to be the parent node.
|
|
360 * Note: may be the "root" node!
|
|
361 */
|
|
362 xmlnode *y;
|
|
363 if((y = xmlnode_get_child(x, new_tag)) != NULL) {
|
|
364 return(y);
|
|
365 }
|
|
366 }
|
|
367 }
|
|
368
|
|
369 /*
|
|
370 * insert the new tag into its parent node
|
|
371 */
|
|
372 return(xmlnode_new_child((x == NULL? start : x), new_tag));
|
|
373 }
|
|
374
|
|
375 /*
|
|
376 * Send vCard info to Jabber server
|
|
377 */
|
|
378 void jabber_set_info(GaimConnection *gc, const char *info)
|
|
379 {
|
|
380 JabberIq *iq;
|
|
381 JabberStream *js = gc->proto_data;
|
|
382 xmlnode *vc_node;
|
|
383 char *avatar_file = NULL;
|
|
384 struct tag_attr *tag_attr;
|
|
385
|
|
386 if(js->avatar_hash)
|
|
387 g_free(js->avatar_hash);
|
|
388 js->avatar_hash = NULL;
|
|
389
|
|
390 /*
|
|
391 * Send only if there's actually any *information* to send
|
|
392 */
|
|
393 vc_node = info ? xmlnode_from_str(info, -1) : NULL;
|
|
394 avatar_file = gaim_buddy_icons_get_full_path(gaim_account_get_buddy_icon(gc->account));
|
|
395
|
|
396 if(!vc_node && avatar_file) {
|
|
397 vc_node = xmlnode_new("vCard");
|
|
398 for(tag_attr = vcard_tag_attr_list; tag_attr->attr != NULL; ++tag_attr)
|
|
399 xmlnode_set_attrib(vc_node, tag_attr->attr, tag_attr->value);
|
|
400 }
|
|
401
|
|
402 if(vc_node) {
|
|
403 if (vc_node->name &&
|
|
404 !g_ascii_strncasecmp(vc_node->name, "vCard", 5)) {
|
|
405 GError *error = NULL;
|
|
406 gchar *avatar_data_tmp;
|
|
407 guchar *avatar_data;
|
|
408 gsize avatar_len;
|
|
409
|
|
410 if(avatar_file && g_file_get_contents(avatar_file, &avatar_data_tmp, &avatar_len, &error)) {
|
|
411 xmlnode *photo, *binval;
|
|
412 gchar *enc;
|
|
413 int i;
|
|
414 unsigned char hashval[20];
|
|
415 char *p, hash[41];
|
|
416
|
|
417 avatar_data = (guchar *) avatar_data_tmp;
|
|
418 photo = xmlnode_new_child(vc_node, "PHOTO");
|
|
419 binval = xmlnode_new_child(photo, "BINVAL");
|
|
420 enc = gaim_base64_encode(avatar_data, avatar_len);
|
|
421
|
|
422 gaim_cipher_digest_region("sha1", (guchar *)avatar_data,
|
|
423 avatar_len, sizeof(hashval),
|
|
424 hashval, NULL);
|
|
425
|
|
426 p = hash;
|
|
427 for(i=0; i<20; i++, p+=2)
|
|
428 snprintf(p, 3, "%02x", hashval[i]);
|
|
429 js->avatar_hash = g_strdup(hash);
|
|
430
|
|
431 xmlnode_insert_data(binval, enc, -1);
|
|
432 g_free(enc);
|
|
433 g_free(avatar_data);
|
|
434 } else if (error != NULL) {
|
|
435 g_error_free(error);
|
|
436 }
|
|
437 g_free(avatar_file);
|
|
438
|
|
439 iq = jabber_iq_new(js, JABBER_IQ_SET);
|
|
440 xmlnode_insert_child(iq->node, vc_node);
|
|
441 jabber_iq_send(iq);
|
|
442 } else {
|
|
443 xmlnode_free(vc_node);
|
|
444 }
|
|
445 }
|
|
446 }
|
|
447
|
|
448 void jabber_set_buddy_icon(GaimConnection *gc, const char *iconfile)
|
|
449 {
|
|
450 GaimPresence *gpresence;
|
|
451 GaimStatus *status;
|
|
452
|
|
453 jabber_set_info(gc, gaim_account_get_user_info(gc->account));
|
|
454
|
|
455 gpresence = gaim_account_get_presence(gc->account);
|
|
456 status = gaim_presence_get_active_status(gpresence);
|
|
457 jabber_presence_send(gc->account, status);
|
|
458 }
|
|
459
|
|
460 /*
|
|
461 * This is the callback from the "ok clicked" for "set vCard"
|
|
462 *
|
|
463 * Formats GSList data into XML-encoded string and returns a pointer
|
|
464 * to said string.
|
|
465 *
|
|
466 * g_free()'ing the returned string space is the responsibility of
|
|
467 * the caller.
|
|
468 */
|
|
469 static void
|
|
470 jabber_format_info(GaimConnection *gc, GaimRequestFields *fields)
|
|
471 {
|
|
472 xmlnode *vc_node;
|
|
473 GaimRequestField *field;
|
|
474 const char *text;
|
|
475 char *p;
|
|
476 const struct vcard_template *vc_tp;
|
|
477 struct tag_attr *tag_attr;
|
|
478
|
|
479 vc_node = xmlnode_new("vCard");
|
|
480
|
|
481 for(tag_attr = vcard_tag_attr_list; tag_attr->attr != NULL; ++tag_attr)
|
|
482 xmlnode_set_attrib(vc_node, tag_attr->attr, tag_attr->value);
|
|
483
|
|
484 for (vc_tp = vcard_template_data; vc_tp->label != NULL; vc_tp++) {
|
|
485 if (*vc_tp->label == '\0')
|
|
486 continue;
|
|
487
|
|
488 field = gaim_request_fields_get_field(fields, vc_tp->tag);
|
|
489 text = gaim_request_field_string_get_value(field);
|
|
490
|
|
491
|
|
492 if (text != NULL && *text != '\0') {
|
|
493 xmlnode *xp;
|
|
494
|
|
495 gaim_debug(GAIM_DEBUG_INFO, "jabber",
|
|
496 "Setting %s to '%s'\n", vc_tp->tag, text);
|
|
497
|
|
498 if ((xp = insert_tag_to_parent_tag(vc_node,
|
|
499 NULL, vc_tp->tag)) != NULL) {
|
|
500
|
|
501 xmlnode_insert_data(xp, text, -1);
|
|
502 }
|
|
503 }
|
|
504 }
|
|
505
|
|
506 p = xmlnode_to_str(vc_node, NULL);
|
|
507 xmlnode_free(vc_node);
|
|
508
|
14607
|
509 gaim_account_set_user_info(gaim_connection_get_account(gc), p);
|
|
510 serv_set_info(gc, p);
|
14192
|
511
|
|
512 g_free(p);
|
|
513 }
|
|
514
|
|
515 /*
|
|
516 * This gets executed by the proto action
|
|
517 *
|
|
518 * Creates a new GaimRequestFields struct, gets the XML-formatted user_info
|
|
519 * string (if any) into GSLists for the (multi-entry) edit dialog and
|
|
520 * calls the set_vcard dialog.
|
|
521 */
|
|
522 void jabber_setup_set_info(GaimPluginAction *action)
|
|
523 {
|
|
524 GaimConnection *gc = (GaimConnection *) action->context;
|
|
525 GaimRequestFields *fields;
|
|
526 GaimRequestFieldGroup *group;
|
|
527 GaimRequestField *field;
|
|
528 const struct vcard_template *vc_tp;
|
|
529 const char *user_info;
|
|
530 char *cdata = NULL;
|
|
531 xmlnode *x_vc_data = NULL;
|
|
532
|
|
533 fields = gaim_request_fields_new();
|
|
534 group = gaim_request_field_group_new(NULL);
|
|
535 gaim_request_fields_add_group(fields, group);
|
|
536
|
|
537 /*
|
|
538 * Get existing, XML-formatted, user info
|
|
539 */
|
|
540 if((user_info = gaim_account_get_user_info(gc->account)) != NULL)
|
|
541 x_vc_data = xmlnode_from_str(user_info, -1);
|
|
542
|
|
543 /*
|
|
544 * Set up GSLists for edit with labels from "template," data from user info
|
|
545 */
|
|
546 for(vc_tp = vcard_template_data; vc_tp->label != NULL; ++vc_tp) {
|
|
547 xmlnode *data_node;
|
|
548 if((vc_tp->label)[0] == '\0')
|
|
549 continue;
|
|
550
|
|
551 if (x_vc_data != NULL) {
|
|
552 if(vc_tp->ptag == NULL) {
|
|
553 data_node = xmlnode_get_child(x_vc_data, vc_tp->tag);
|
|
554 } else {
|
|
555 gchar *tag = g_strdup_printf("%s/%s", vc_tp->ptag, vc_tp->tag);
|
|
556 data_node = xmlnode_get_child(x_vc_data, tag);
|
|
557 g_free(tag);
|
|
558 }
|
|
559 if(data_node)
|
|
560 cdata = xmlnode_get_data(data_node);
|
|
561 }
|
|
562
|
|
563 if(strcmp(vc_tp->tag, "DESC") == 0) {
|
|
564 field = gaim_request_field_string_new(vc_tp->tag,
|
|
565 _(vc_tp->label), cdata,
|
|
566 TRUE);
|
|
567 } else {
|
|
568 field = gaim_request_field_string_new(vc_tp->tag,
|
|
569 _(vc_tp->label), cdata,
|
|
570 FALSE);
|
|
571 }
|
|
572
|
|
573 g_free(cdata);
|
|
574 cdata = NULL;
|
|
575
|
|
576 gaim_request_field_group_add_field(group, field);
|
|
577 }
|
|
578
|
|
579 if(x_vc_data != NULL)
|
|
580 xmlnode_free(x_vc_data);
|
|
581
|
|
582 gaim_request_fields(gc, _("Edit Jabber vCard"),
|
|
583 _("Edit Jabber vCard"),
|
|
584 _("All items below are optional. Enter only the "
|
|
585 "information with which you feel comfortable."),
|
|
586 fields,
|
|
587 _("Save"), G_CALLBACK(jabber_format_info),
|
|
588 _("Cancel"), NULL,
|
|
589 gc);
|
|
590 }
|
|
591
|
|
592 /*---------------------------------------*/
|
|
593 /* End Jabber "set info" (vCard) support */
|
|
594 /*---------------------------------------*/
|
|
595
|
|
596 /******
|
|
597 * end of that ancient crap that needs to die
|
|
598 ******/
|
|
599
|
|
600 static void jabber_buddy_info_show_if_ready(JabberBuddyInfo *jbi)
|
|
601 {
|
|
602 GString *info_text;
|
|
603 char *resource_name;
|
|
604 JabberBuddyResource *jbr;
|
15030
|
605 JabberBuddyInfoResource *jbir = NULL;
|
14192
|
606 GList *resources;
|
|
607
|
|
608 /* not yet */
|
|
609 if(jbi->ids)
|
|
610 return;
|
|
611
|
|
612 info_text = g_string_new("");
|
|
613 resource_name = jabber_get_resource(jbi->jid);
|
|
614
|
|
615 if(resource_name) {
|
|
616 jbr = jabber_buddy_find_resource(jbi->jb, resource_name);
|
|
617 jbir = g_hash_table_lookup(jbi->resources, resource_name);
|
|
618 if(jbr) {
|
|
619 char *purdy = NULL;
|
|
620 if(jbr->status)
|
|
621 purdy = gaim_strdup_withhtml(jbr->status);
|
|
622 g_string_append_printf(info_text, "<b>%s:</b> %s%s%s<br/>",
|
|
623 _("Status"), jabber_buddy_state_get_name(jbr->state),
|
|
624 purdy ? ": " : "",
|
|
625 purdy ? purdy : "");
|
|
626 if(purdy)
|
|
627 g_free(purdy);
|
|
628 } else {
|
|
629 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
630 _("Status"), _("Unknown"));
|
|
631 }
|
|
632 if(jbir) {
|
|
633 if(jbir->idle_seconds > 0) {
|
|
634 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
635 _("Idle"), gaim_str_seconds_to_string(jbir->idle_seconds));
|
|
636 }
|
|
637 }
|
|
638 if(jbr && jbr->client.name) {
|
|
639 g_string_append_printf(info_text, "<b>%s:</b> %s %s<br/>",
|
|
640 _("Client:"), jbr->client.name,
|
|
641 jbr->client.version ? jbr->client.version : "");
|
|
642 if(jbr->client.os) {
|
|
643 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
644 _("Operating System"), jbr->client.os);
|
|
645 }
|
|
646 }
|
|
647 } else {
|
|
648 for(resources = jbi->jb->resources; resources; resources = resources->next) {
|
|
649 char *purdy = NULL;
|
|
650 jbr = resources->data;
|
|
651 if(jbr->status)
|
|
652 purdy = gaim_strdup_withhtml(jbr->status);
|
15030
|
653 if(jbr->name)
|
|
654 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
655 _("Resource"), jbr->name);
|
14463
|
656 g_string_append_printf(info_text, "<b>%s:</b> %d<br/>",
|
|
657 _("Priority"), jbr->priority);
|
14192
|
658 g_string_append_printf(info_text, "<b>%s:</b> %s%s%s<br/>",
|
|
659 _("Status"), jabber_buddy_state_get_name(jbr->state),
|
|
660 purdy ? ": " : "",
|
|
661 purdy ? purdy : "");
|
|
662 if(purdy)
|
|
663 g_free(purdy);
|
|
664
|
15030
|
665 if(jbr->name)
|
|
666 jbir = g_hash_table_lookup(jbi->resources, jbr->name);
|
|
667
|
14192
|
668 if(jbir) {
|
|
669 if(jbir->idle_seconds > 0) {
|
|
670 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
671 _("Idle"), gaim_str_seconds_to_string(jbir->idle_seconds));
|
|
672 }
|
|
673 }
|
|
674 if(jbr->client.name) {
|
|
675 g_string_append_printf(info_text, "<b>%s:</b> %s %s<br/>",
|
|
676 _("Client"), jbr->client.name,
|
|
677 jbr->client.version ? jbr->client.version : "");
|
|
678 if(jbr->client.os) {
|
|
679 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
680 _("Operating System"), jbr->client.os);
|
|
681 }
|
|
682 }
|
|
683
|
|
684 g_string_append_printf(info_text, "<br/>");
|
|
685 }
|
|
686 }
|
|
687
|
|
688 g_free(resource_name);
|
|
689
|
|
690 if (jbi->vcard_text != NULL)
|
|
691 info_text = g_string_append(info_text, jbi->vcard_text);
|
|
692
|
|
693 gaim_notify_userinfo(jbi->js->gc, jbi->jid, info_text->str, NULL, NULL);
|
|
694
|
|
695 while(jbi->vcard_imgids) {
|
|
696 gaim_imgstore_unref(GPOINTER_TO_INT(jbi->vcard_imgids->data));
|
|
697 jbi->vcard_imgids = g_slist_delete_link(jbi->vcard_imgids, jbi->vcard_imgids);
|
|
698 }
|
|
699
|
|
700 g_string_free(info_text, TRUE);
|
|
701
|
|
702 if (jbi->timeout_handle > 0)
|
|
703 gaim_timeout_remove(jbi->timeout_handle);
|
|
704
|
|
705 g_free(jbi->jid);
|
|
706 g_hash_table_destroy(jbi->resources);
|
|
707 g_free(jbi->vcard_text);
|
|
708 g_free(jbi);
|
|
709 }
|
|
710
|
|
711 static void jabber_buddy_info_remove_id(JabberBuddyInfo *jbi, const char *id)
|
|
712 {
|
|
713 GSList *l = jbi->ids;
|
|
714
|
|
715 if(!id)
|
|
716 return;
|
|
717
|
|
718 while(l) {
|
|
719 if(!strcmp(id, l->data)) {
|
|
720 jbi->ids = g_slist_remove(jbi->ids, l->data);
|
|
721 return;
|
|
722 }
|
|
723 l = l->next;
|
|
724 }
|
|
725 }
|
|
726
|
|
727 static void jabber_vcard_parse(JabberStream *js, xmlnode *packet, gpointer data)
|
|
728 {
|
|
729 const char *id, *from;
|
|
730 GString *info_text;
|
|
731 char *bare_jid;
|
|
732 char *text;
|
|
733 xmlnode *vcard;
|
|
734 GaimBuddy *b;
|
|
735 JabberBuddyInfo *jbi = data;
|
|
736
|
|
737 from = xmlnode_get_attrib(packet, "from");
|
|
738 id = xmlnode_get_attrib(packet, "id");
|
|
739
|
|
740 if(!jbi)
|
|
741 return;
|
|
742
|
|
743 jabber_buddy_info_remove_id(jbi, id);
|
|
744
|
|
745 if(!from)
|
|
746 return;
|
|
747
|
|
748 if(!jabber_buddy_find(js, from, FALSE))
|
|
749 return;
|
|
750
|
|
751 /* XXX: handle the error case */
|
|
752
|
|
753 bare_jid = jabber_get_bare_jid(from);
|
|
754
|
|
755 b = gaim_find_buddy(js->gc->account, bare_jid);
|
|
756
|
|
757 info_text = g_string_new("");
|
|
758
|
|
759 if((vcard = xmlnode_get_child(packet, "vCard")) ||
|
|
760 (vcard = xmlnode_get_child_with_namespace(packet, "query", "vcard-temp"))) {
|
|
761 xmlnode *child;
|
|
762 for(child = vcard->child; child; child = child->next)
|
|
763 {
|
|
764 xmlnode *child2;
|
|
765
|
|
766 if(child->type != XMLNODE_TYPE_TAG)
|
|
767 continue;
|
|
768
|
|
769 text = xmlnode_get_data(child);
|
|
770 if(text && !strcmp(child->name, "FN")) {
|
|
771 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
772 _("Full Name"), text);
|
|
773 } else if(!strcmp(child->name, "N")) {
|
|
774 for(child2 = child->child; child2; child2 = child2->next)
|
|
775 {
|
|
776 char *text2;
|
|
777
|
|
778 if(child2->type != XMLNODE_TYPE_TAG)
|
|
779 continue;
|
|
780
|
|
781 text2 = xmlnode_get_data(child2);
|
|
782 if(text2 && !strcmp(child2->name, "FAMILY")) {
|
|
783 g_string_append_printf(info_text,
|
|
784 "<b>%s:</b> %s<br/>",
|
|
785 _("Family Name"), text2);
|
|
786 } else if(text2 && !strcmp(child2->name, "GIVEN")) {
|
|
787 g_string_append_printf(info_text,
|
|
788 "<b>%s:</b> %s<br/>",
|
|
789 _("Given Name"), text2);
|
|
790 } else if(text2 && !strcmp(child2->name, "MIDDLE")) {
|
|
791 g_string_append_printf(info_text,
|
|
792 "<b>%s:</b> %s<br/>",
|
|
793 _("Middle Name"), text2);
|
|
794 }
|
|
795 g_free(text2);
|
|
796 }
|
|
797 } else if(text && !strcmp(child->name, "NICKNAME")) {
|
|
798 serv_got_alias(js->gc, from, text);
|
|
799 if(b) {
|
|
800 gaim_blist_node_set_string((GaimBlistNode*)b, "servernick", text);
|
|
801 }
|
|
802 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
803 _("Nickname"), text);
|
|
804 } else if(text && !strcmp(child->name, "BDAY")) {
|
|
805 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
806 _("Birthday"), text);
|
|
807 } else if(!strcmp(child->name, "ADR")) {
|
|
808 gboolean address_line_added = FALSE;
|
|
809
|
|
810 for(child2 = child->child; child2; child2 = child2->next)
|
|
811 {
|
|
812 char *text2;
|
|
813
|
|
814 if(child2->type != XMLNODE_TYPE_TAG)
|
|
815 continue;
|
|
816
|
|
817 text2 = xmlnode_get_data(child2);
|
|
818 if (text2 == NULL)
|
|
819 continue;
|
|
820
|
|
821 /* We do this here so that it's not added if all the child
|
|
822 * elements are empty. */
|
|
823 if (!address_line_added)
|
|
824 {
|
|
825 g_string_append_printf(info_text, "<b>%s:</b><br/>",
|
|
826 _("Address"));
|
|
827 address_line_added = TRUE;
|
|
828 }
|
|
829
|
|
830 if(!strcmp(child2->name, "POBOX")) {
|
|
831 g_string_append_printf(info_text,
|
|
832 " <b>%s:</b> %s<br/>",
|
|
833 _("P.O. Box"), text2);
|
|
834 } else if(!strcmp(child2->name, "EXTADR")) {
|
|
835 g_string_append_printf(info_text,
|
|
836 " <b>%s:</b> %s<br/>",
|
|
837 _("Extended Address"), text2);
|
|
838 } else if(!strcmp(child2->name, "STREET")) {
|
|
839 g_string_append_printf(info_text,
|
|
840 " <b>%s:</b> %s<br/>",
|
|
841 _("Street Address"), text2);
|
|
842 } else if(!strcmp(child2->name, "LOCALITY")) {
|
|
843 g_string_append_printf(info_text,
|
|
844 " <b>%s:</b> %s<br/>",
|
|
845 _("Locality"), text2);
|
|
846 } else if(!strcmp(child2->name, "REGION")) {
|
|
847 g_string_append_printf(info_text,
|
|
848 " <b>%s:</b> %s<br/>",
|
|
849 _("Region"), text2);
|
|
850 } else if(!strcmp(child2->name, "PCODE")) {
|
|
851 g_string_append_printf(info_text,
|
|
852 " <b>%s:</b> %s<br/>",
|
|
853 _("Postal Code"), text2);
|
|
854 } else if(!strcmp(child2->name, "CTRY")
|
|
855 || !strcmp(child2->name, "COUNTRY")) {
|
|
856 g_string_append_printf(info_text,
|
|
857 " <b>%s:</b> %s<br/>",
|
|
858 _("Country"), text2);
|
|
859 }
|
|
860 g_free(text2);
|
|
861 }
|
|
862 } else if(!strcmp(child->name, "TEL")) {
|
|
863 char *number;
|
|
864 if((child2 = xmlnode_get_child(child, "NUMBER"))) {
|
|
865 /* show what kind of number it is */
|
|
866 number = xmlnode_get_data(child2);
|
|
867 if(number) {
|
|
868 g_string_append_printf(info_text,
|
|
869 "<b>%s:</b> %s<br/>", _("Telephone"), number);
|
|
870 g_free(number);
|
|
871 }
|
|
872 } else if((number = xmlnode_get_data(child))) {
|
|
873 /* lots of clients (including gaim) do this, but it's
|
|
874 * out of spec */
|
|
875 g_string_append_printf(info_text,
|
|
876 "<b>%s:</b> %s<br/>", _("Telephone"), number);
|
|
877 g_free(number);
|
|
878 }
|
|
879 } else if(!strcmp(child->name, "EMAIL")) {
|
|
880 char *userid;
|
|
881 if((child2 = xmlnode_get_child(child, "USERID"))) {
|
|
882 /* show what kind of email it is */
|
|
883 userid = xmlnode_get_data(child2);
|
|
884 if(userid) {
|
|
885 g_string_append_printf(info_text,
|
|
886 "<b>%s:</b> <a href='mailto:%s'>%s</a><br/>",
|
|
887 _("E-Mail"), userid, userid);
|
|
888 g_free(userid);
|
|
889 }
|
|
890 } else if((userid = xmlnode_get_data(child))) {
|
|
891 /* lots of clients (including gaim) do this, but it's
|
|
892 * out of spec */
|
|
893 g_string_append_printf(info_text,
|
|
894 "<b>%s:</b> <a href='mailto:%s'>%s</a><br/>",
|
|
895 _("E-Mail"), userid, userid);
|
|
896 g_free(userid);
|
|
897 }
|
|
898 } else if(!strcmp(child->name, "ORG")) {
|
|
899 for(child2 = child->child; child2; child2 = child2->next)
|
|
900 {
|
|
901 char *text2;
|
|
902
|
|
903 if(child2->type != XMLNODE_TYPE_TAG)
|
|
904 continue;
|
|
905
|
|
906 text2 = xmlnode_get_data(child2);
|
|
907 if(text2 && !strcmp(child2->name, "ORGNAME")) {
|
|
908 g_string_append_printf(info_text,
|
|
909 "<b>%s:</b> %s<br/>",
|
|
910 _("Organization Name"), text2);
|
|
911 } else if(text2 && !strcmp(child2->name, "ORGUNIT")) {
|
|
912 g_string_append_printf(info_text,
|
|
913 "<b>%s:</b> %s<br/>",
|
|
914 _("Organization Unit"), text2);
|
|
915 }
|
|
916 g_free(text2);
|
|
917 }
|
|
918 } else if(text && !strcmp(child->name, "TITLE")) {
|
|
919 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
920 _("Title"), text);
|
|
921 } else if(text && !strcmp(child->name, "ROLE")) {
|
|
922 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
923 _("Role"), text);
|
|
924 } else if(text && !strcmp(child->name, "DESC")) {
|
|
925 g_string_append_printf(info_text, "<b>%s:</b> %s<br/>",
|
|
926 _("Description"), text);
|
|
927 } else if(!strcmp(child->name, "PHOTO") ||
|
|
928 !strcmp(child->name, "LOGO")) {
|
|
929 char *bintext = NULL;
|
|
930 xmlnode *binval;
|
|
931
|
|
932 if( ((binval = xmlnode_get_child(child, "BINVAL")) &&
|
|
933 (bintext = xmlnode_get_data(binval))) ||
|
|
934 (bintext = xmlnode_get_data(child))) {
|
|
935 gsize size;
|
|
936 guchar *data;
|
|
937 int i;
|
|
938 unsigned char hashval[20];
|
|
939 char *p, hash[41];
|
|
940 gboolean photo = (strcmp(child->name, "PHOTO") == 0);
|
|
941
|
|
942 data = gaim_base64_decode(bintext, &size);
|
|
943
|
|
944 jbi->vcard_imgids = g_slist_prepend(jbi->vcard_imgids, GINT_TO_POINTER(gaim_imgstore_add(data, size, "logo.png")));
|
|
945 g_string_append_printf(info_text,
|
|
946 "<b>%s:</b> <img id='%d'><br/>",
|
|
947 photo ? _("Photo") : _("Logo"),
|
|
948 GPOINTER_TO_INT(jbi->vcard_imgids->data));
|
|
949
|
|
950 gaim_buddy_icons_set_for_user(js->gc->account, bare_jid,
|
|
951 data, size);
|
|
952
|
|
953 gaim_cipher_digest_region("sha1", (guchar *)data, size,
|
|
954 sizeof(hashval), hashval, NULL);
|
|
955 p = hash;
|
|
956 for(i=0; i<20; i++, p+=2)
|
|
957 snprintf(p, 3, "%02x", hashval[i]);
|
|
958 gaim_blist_node_set_string((GaimBlistNode*)b, "avatar_hash", hash);
|
|
959
|
|
960 g_free(data);
|
|
961 g_free(bintext);
|
|
962 }
|
|
963 }
|
|
964 g_free(text);
|
|
965 }
|
|
966 }
|
|
967
|
|
968 jbi->vcard_text = gaim_strdup_withhtml(info_text->str);
|
|
969 g_string_free(info_text, TRUE);
|
|
970 g_free(bare_jid);
|
|
971
|
|
972 jabber_buddy_info_show_if_ready(jbi);
|
|
973 }
|
|
974
|
|
975
|
|
976 static void jabber_buddy_info_resource_free(gpointer data)
|
|
977 {
|
|
978 JabberBuddyInfoResource *jbri = data;
|
|
979 g_free(jbri);
|
|
980 }
|
|
981
|
|
982 static void jabber_version_parse(JabberStream *js, xmlnode *packet, gpointer data)
|
|
983 {
|
|
984 JabberBuddyInfo *jbi = data;
|
|
985 const char *type, *id, *from;
|
|
986 xmlnode *query;
|
|
987 char *resource_name;
|
|
988
|
|
989 g_return_if_fail(jbi != NULL);
|
|
990
|
|
991 type = xmlnode_get_attrib(packet, "type");
|
|
992 id = xmlnode_get_attrib(packet, "id");
|
|
993 from = xmlnode_get_attrib(packet, "from");
|
|
994
|
|
995 jabber_buddy_info_remove_id(jbi, id);
|
|
996
|
|
997 if(!from)
|
|
998 return;
|
|
999
|
|
1000 resource_name = jabber_get_resource(from);
|
|
1001
|
|
1002 if(resource_name) {
|
|
1003 if(type && !strcmp(type, "result")) {
|
|
1004 if((query = xmlnode_get_child(packet, "query"))) {
|
|
1005 JabberBuddyResource *jbr = jabber_buddy_find_resource(jbi->jb, resource_name);
|
|
1006 if(jbr) {
|
|
1007 xmlnode *node;
|
|
1008 if((node = xmlnode_get_child(query, "name"))) {
|
|
1009 jbr->client.name = xmlnode_get_data(node);
|
|
1010 }
|
|
1011 if((node = xmlnode_get_child(query, "version"))) {
|
|
1012 jbr->client.version = xmlnode_get_data(node);
|
|
1013 }
|
|
1014 if((node = xmlnode_get_child(query, "os"))) {
|
|
1015 jbr->client.os = xmlnode_get_data(node);
|
|
1016 }
|
|
1017 }
|
|
1018 }
|
|
1019 }
|
|
1020 g_free(resource_name);
|
|
1021 }
|
|
1022
|
|
1023 jabber_buddy_info_show_if_ready(jbi);
|
|
1024 }
|
|
1025
|
|
1026 static void jabber_last_parse(JabberStream *js, xmlnode *packet, gpointer data)
|
|
1027 {
|
|
1028 JabberBuddyInfo *jbi = data;
|
|
1029 xmlnode *query;
|
|
1030 char *resource_name;
|
|
1031 const char *type, *id, *from, *seconds;
|
|
1032
|
|
1033 g_return_if_fail(jbi != NULL);
|
|
1034
|
|
1035 type = xmlnode_get_attrib(packet, "type");
|
|
1036 id = xmlnode_get_attrib(packet, "id");
|
|
1037 from = xmlnode_get_attrib(packet, "from");
|
|
1038
|
|
1039 jabber_buddy_info_remove_id(jbi, id);
|
|
1040
|
|
1041 if(!from)
|
|
1042 return;
|
|
1043
|
|
1044 resource_name = jabber_get_resource(from);
|
|
1045
|
|
1046 if(resource_name) {
|
|
1047 if(type && !strcmp(type, "result")) {
|
|
1048 if((query = xmlnode_get_child(packet, "query"))) {
|
|
1049 seconds = xmlnode_get_attrib(query, "seconds");
|
|
1050 if(seconds) {
|
|
1051 char *end = NULL;
|
|
1052 long sec = strtol(seconds, &end, 10);
|
|
1053 if(end != seconds) {
|
|
1054 JabberBuddyInfoResource *jbir = g_hash_table_lookup(jbi->resources, resource_name);
|
|
1055 if(jbir) {
|
|
1056 jbir->idle_seconds = sec;
|
|
1057 }
|
|
1058 }
|
|
1059 }
|
|
1060 }
|
|
1061 }
|
|
1062 g_free(resource_name);
|
|
1063 }
|
|
1064
|
|
1065 jabber_buddy_info_show_if_ready(jbi);
|
|
1066 }
|
|
1067
|
|
1068 static gboolean jabber_buddy_get_info_timeout(gpointer data)
|
|
1069 {
|
|
1070 JabberBuddyInfo *jbi = data;
|
|
1071
|
|
1072 /* remove the pending callbacks */
|
|
1073 while(jbi->ids) {
|
|
1074 char *id = jbi->ids->data;
|
|
1075 jabber_iq_remove_callback_by_id(jbi->js, id);
|
|
1076 g_free(id);
|
|
1077 jbi->ids = g_slist_remove(jbi->ids, id);
|
|
1078 }
|
|
1079
|
|
1080 jbi->timeout_handle = 0;
|
|
1081
|
|
1082 jabber_buddy_info_show_if_ready(jbi);
|
|
1083
|
|
1084 return FALSE;
|
|
1085 }
|
|
1086
|
|
1087 static void jabber_buddy_get_info_for_jid(JabberStream *js, const char *jid)
|
|
1088 {
|
|
1089 JabberIq *iq;
|
|
1090 xmlnode *vcard;
|
|
1091 GList *resources;
|
|
1092 JabberBuddy *jb;
|
|
1093 JabberBuddyInfo *jbi;
|
|
1094
|
|
1095 jb = jabber_buddy_find(js, jid, TRUE);
|
|
1096
|
|
1097 /* invalid JID */
|
|
1098 if(!jb)
|
|
1099 return;
|
|
1100
|
|
1101 jbi = g_new0(JabberBuddyInfo, 1);
|
|
1102 jbi->jid = g_strdup(jid);
|
|
1103 jbi->js = js;
|
|
1104 jbi->jb = jb;
|
|
1105 jbi->resources = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, jabber_buddy_info_resource_free);
|
|
1106
|
|
1107 iq = jabber_iq_new(js, JABBER_IQ_GET);
|
|
1108
|
|
1109 xmlnode_set_attrib(iq->node, "to", jid);
|
|
1110 vcard = xmlnode_new_child(iq->node, "vCard");
|
|
1111 xmlnode_set_namespace(vcard, "vcard-temp");
|
|
1112
|
|
1113 jabber_iq_set_callback(iq, jabber_vcard_parse, jbi);
|
|
1114 jbi->ids = g_slist_prepend(jbi->ids, g_strdup(iq->id));
|
|
1115
|
|
1116 jabber_iq_send(iq);
|
|
1117
|
|
1118 for(resources = jb->resources; resources; resources = resources->next)
|
|
1119 {
|
|
1120 JabberBuddyResource *jbr = resources->data;
|
|
1121 JabberBuddyInfoResource *jbir;
|
|
1122 char *full_jid;
|
|
1123
|
|
1124 if ((strchr(jid, '/') == NULL) && (jbr->name != NULL)) {
|
|
1125 full_jid = g_strdup_printf("%s/%s", jid, jbr->name);
|
|
1126 } else {
|
|
1127 full_jid = g_strdup(jid);
|
|
1128 }
|
|
1129
|
|
1130 if (jbr->name != NULL)
|
|
1131 {
|
|
1132 jbir = g_new0(JabberBuddyInfoResource, 1);
|
|
1133 g_hash_table_insert(jbi->resources, g_strdup(jbr->name), jbir);
|
|
1134 }
|
|
1135
|
|
1136 if(!jbr->client.name) {
|
|
1137 iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:version");
|
|
1138 xmlnode_set_attrib(iq->node, "to", full_jid);
|
|
1139 jabber_iq_set_callback(iq, jabber_version_parse, jbi);
|
|
1140 jbi->ids = g_slist_prepend(jbi->ids, g_strdup(iq->id));
|
|
1141 jabber_iq_send(iq);
|
|
1142 }
|
|
1143
|
|
1144 iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:last");
|
|
1145 xmlnode_set_attrib(iq->node, "to", full_jid);
|
|
1146 jabber_iq_set_callback(iq, jabber_last_parse, jbi);
|
|
1147 jbi->ids = g_slist_prepend(jbi->ids, g_strdup(iq->id));
|
|
1148 jabber_iq_send(iq);
|
|
1149
|
|
1150 g_free(full_jid);
|
|
1151 }
|
|
1152
|
|
1153 jbi->timeout_handle = gaim_timeout_add(30000, jabber_buddy_get_info_timeout, jbi);
|
|
1154 }
|
|
1155
|
|
1156 void jabber_buddy_get_info(GaimConnection *gc, const char *who)
|
|
1157 {
|
|
1158 JabberStream *js = gc->proto_data;
|
|
1159 char *bare_jid = jabber_get_bare_jid(who);
|
|
1160
|
|
1161 if(bare_jid) {
|
|
1162 jabber_buddy_get_info_for_jid(js, bare_jid);
|
|
1163 g_free(bare_jid);
|
|
1164 }
|
|
1165 }
|
|
1166
|
|
1167 void jabber_buddy_get_info_chat(GaimConnection *gc, int id,
|
|
1168 const char *resource)
|
|
1169 {
|
|
1170 JabberStream *js = gc->proto_data;
|
|
1171 JabberChat *chat = jabber_chat_find_by_id(js, id);
|
|
1172 char *full_jid;
|
|
1173
|
|
1174 if(!chat)
|
|
1175 return;
|
|
1176
|
|
1177 full_jid = g_strdup_printf("%s@%s/%s", chat->room, chat->server, resource);
|
|
1178 jabber_buddy_get_info_for_jid(js, full_jid);
|
|
1179 g_free(full_jid);
|
|
1180 }
|
|
1181
|
|
1182
|
|
1183 static void jabber_buddy_set_invisibility(JabberStream *js, const char *who,
|
|
1184 gboolean invisible)
|
|
1185 {
|
|
1186 GaimPresence *gpresence;
|
|
1187 GaimAccount *account;
|
|
1188 GaimStatus *status;
|
|
1189 JabberBuddy *jb = jabber_buddy_find(js, who, TRUE);
|
|
1190 xmlnode *presence;
|
|
1191 JabberBuddyState state;
|
14463
|
1192 char *msg;
|
14192
|
1193 int priority;
|
|
1194
|
|
1195 account = gaim_connection_get_account(js->gc);
|
|
1196 gpresence = gaim_account_get_presence(account);
|
|
1197 status = gaim_presence_get_active_status(gpresence);
|
|
1198
|
|
1199 gaim_status_to_jabber(status, &state, &msg, &priority);
|
|
1200 presence = jabber_presence_create(state, msg, priority);
|
|
1201
|
14463
|
1202 g_free(msg);
|
|
1203
|
14192
|
1204 xmlnode_set_attrib(presence, "to", who);
|
|
1205 if(invisible) {
|
|
1206 xmlnode_set_attrib(presence, "type", "invisible");
|
|
1207 jb->invisible |= JABBER_INVIS_BUDDY;
|
|
1208 } else {
|
|
1209 jb->invisible &= ~JABBER_INVIS_BUDDY;
|
|
1210 }
|
|
1211
|
|
1212 jabber_send(js, presence);
|
|
1213 xmlnode_free(presence);
|
|
1214 }
|
|
1215
|
|
1216 static void jabber_buddy_make_invisible(GaimBlistNode *node, gpointer data)
|
|
1217 {
|
|
1218 GaimBuddy *buddy;
|
|
1219 GaimConnection *gc;
|
|
1220 JabberStream *js;
|
|
1221
|
|
1222 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node));
|
|
1223
|
|
1224 buddy = (GaimBuddy *) node;
|
|
1225 gc = gaim_account_get_connection(buddy->account);
|
|
1226 js = gc->proto_data;
|
|
1227
|
|
1228 jabber_buddy_set_invisibility(js, buddy->name, TRUE);
|
|
1229 }
|
|
1230
|
|
1231 static void jabber_buddy_make_visible(GaimBlistNode *node, gpointer data)
|
|
1232 {
|
|
1233 GaimBuddy *buddy;
|
|
1234 GaimConnection *gc;
|
|
1235 JabberStream *js;
|
|
1236
|
|
1237 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node));
|
|
1238
|
|
1239 buddy = (GaimBuddy *) node;
|
|
1240 gc = gaim_account_get_connection(buddy->account);
|
|
1241 js = gc->proto_data;
|
|
1242
|
|
1243 jabber_buddy_set_invisibility(js, buddy->name, FALSE);
|
|
1244 }
|
|
1245
|
|
1246 static void jabber_buddy_cancel_presence_notification(GaimBlistNode *node,
|
|
1247 gpointer data)
|
|
1248 {
|
|
1249 GaimBuddy *buddy;
|
|
1250 GaimConnection *gc;
|
|
1251 JabberStream *js;
|
|
1252
|
|
1253 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node));
|
|
1254
|
|
1255 buddy = (GaimBuddy *) node;
|
|
1256 gc = gaim_account_get_connection(buddy->account);
|
|
1257 js = gc->proto_data;
|
|
1258
|
|
1259 /* I wonder if we should prompt the user before doing this */
|
|
1260 jabber_presence_subscription_set(js, buddy->name, "unsubscribed");
|
|
1261 }
|
|
1262
|
|
1263 static void jabber_buddy_rerequest_auth(GaimBlistNode *node, gpointer data)
|
|
1264 {
|
|
1265 GaimBuddy *buddy;
|
|
1266 GaimConnection *gc;
|
|
1267 JabberStream *js;
|
|
1268
|
|
1269 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node));
|
|
1270
|
|
1271 buddy = (GaimBuddy *) node;
|
|
1272 gc = gaim_account_get_connection(buddy->account);
|
|
1273 js = gc->proto_data;
|
|
1274
|
|
1275 jabber_presence_subscription_set(js, buddy->name, "subscribe");
|
|
1276 }
|
|
1277
|
|
1278
|
|
1279 static void jabber_buddy_unsubscribe(GaimBlistNode *node, gpointer data)
|
|
1280 {
|
|
1281 GaimBuddy *buddy;
|
|
1282 GaimConnection *gc;
|
|
1283 JabberStream *js;
|
|
1284
|
|
1285 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node));
|
|
1286
|
|
1287 buddy = (GaimBuddy *) node;
|
|
1288 gc = gaim_account_get_connection(buddy->account);
|
|
1289 js = gc->proto_data;
|
|
1290
|
|
1291 jabber_presence_subscription_set(js, buddy->name, "unsubscribe");
|
|
1292 }
|
|
1293
|
|
1294
|
|
1295 static GList *jabber_buddy_menu(GaimBuddy *buddy)
|
|
1296 {
|
|
1297 GaimConnection *gc = gaim_account_get_connection(buddy->account);
|
|
1298 JabberStream *js = gc->proto_data;
|
|
1299 JabberBuddy *jb = jabber_buddy_find(js, buddy->name, TRUE);
|
|
1300
|
|
1301 GList *m = NULL;
|
|
1302 GaimMenuAction *act;
|
|
1303
|
|
1304 if(!jb)
|
|
1305 return m;
|
|
1306
|
|
1307 /* XXX: fix the NOT ME below */
|
|
1308
|
|
1309 if(js->protocol_version == JABBER_PROTO_0_9 /* && NOT ME */) {
|
|
1310 if(jb->invisible & JABBER_INVIS_BUDDY) {
|
|
1311 act = gaim_menu_action_new(_("Un-hide From"),
|
|
1312 GAIM_CALLBACK(jabber_buddy_make_visible),
|
|
1313 NULL, NULL);
|
|
1314 } else {
|
|
1315 act = gaim_menu_action_new(_("Temporarily Hide From"),
|
|
1316 GAIM_CALLBACK(jabber_buddy_make_invisible),
|
|
1317 NULL, NULL);
|
|
1318 }
|
|
1319 m = g_list_append(m, act);
|
|
1320 }
|
|
1321
|
|
1322 if(jb->subscription & JABBER_SUB_FROM /* && NOT ME */) {
|
|
1323 act = gaim_menu_action_new(_("Cancel Presence Notification"),
|
|
1324 GAIM_CALLBACK(jabber_buddy_cancel_presence_notification),
|
|
1325 NULL, NULL);
|
|
1326 m = g_list_append(m, act);
|
|
1327 }
|
|
1328
|
|
1329 if(!(jb->subscription & JABBER_SUB_TO)) {
|
|
1330 act = gaim_menu_action_new(_("(Re-)Request authorization"),
|
|
1331 GAIM_CALLBACK(jabber_buddy_rerequest_auth),
|
|
1332 NULL, NULL);
|
|
1333 m = g_list_append(m, act);
|
|
1334
|
|
1335 } else /* if(NOT ME) */{
|
|
1336
|
|
1337 /* shouldn't this just happen automatically when the buddy is
|
|
1338 removed? */
|
|
1339 act = gaim_menu_action_new(_("Unsubscribe"),
|
|
1340 GAIM_CALLBACK(jabber_buddy_unsubscribe),
|
|
1341 NULL, NULL);
|
|
1342 m = g_list_append(m, act);
|
|
1343 }
|
|
1344
|
|
1345 return m;
|
|
1346 }
|
|
1347
|
|
1348 GList *
|
|
1349 jabber_blist_node_menu(GaimBlistNode *node)
|
|
1350 {
|
|
1351 if(GAIM_BLIST_NODE_IS_BUDDY(node)) {
|
|
1352 return jabber_buddy_menu((GaimBuddy *) node);
|
|
1353 } else {
|
|
1354 return NULL;
|
|
1355 }
|
|
1356 }
|
|
1357
|
|
1358
|
|
1359 const char *
|
|
1360 jabber_buddy_state_get_name(JabberBuddyState state)
|
|
1361 {
|
|
1362 switch(state) {
|
|
1363 case JABBER_BUDDY_STATE_UNKNOWN:
|
|
1364 return _("Unknown");
|
|
1365 case JABBER_BUDDY_STATE_ERROR:
|
|
1366 return _("Error");
|
|
1367 case JABBER_BUDDY_STATE_UNAVAILABLE:
|
|
1368 return _("Offline");
|
|
1369 case JABBER_BUDDY_STATE_ONLINE:
|
|
1370 return _("Available");
|
|
1371 case JABBER_BUDDY_STATE_CHAT:
|
|
1372 return _("Chatty");
|
|
1373 case JABBER_BUDDY_STATE_AWAY:
|
|
1374 return _("Away");
|
|
1375 case JABBER_BUDDY_STATE_XA:
|
|
1376 return _("Extended Away");
|
|
1377 case JABBER_BUDDY_STATE_DND:
|
|
1378 return _("Do Not Disturb");
|
|
1379 }
|
|
1380
|
|
1381 return _("Unknown");
|
|
1382 }
|
|
1383
|
|
1384 JabberBuddyState jabber_buddy_status_id_get_state(const char *id) {
|
|
1385 if(!id)
|
|
1386 return JABBER_BUDDY_STATE_UNKNOWN;
|
|
1387 if(!strcmp(id, "available"))
|
|
1388 return JABBER_BUDDY_STATE_ONLINE;
|
|
1389 if(!strcmp(id, "freeforchat"))
|
|
1390 return JABBER_BUDDY_STATE_CHAT;
|
|
1391 if(!strcmp(id, "away"))
|
|
1392 return JABBER_BUDDY_STATE_AWAY;
|
|
1393 if(!strcmp(id, "extended_away"))
|
|
1394 return JABBER_BUDDY_STATE_XA;
|
|
1395 if(!strcmp(id, "dnd"))
|
|
1396 return JABBER_BUDDY_STATE_DND;
|
|
1397 if(!strcmp(id, "offline"))
|
|
1398 return JABBER_BUDDY_STATE_UNAVAILABLE;
|
|
1399 if(!strcmp(id, "error"))
|
|
1400 return JABBER_BUDDY_STATE_ERROR;
|
|
1401
|
|
1402 return JABBER_BUDDY_STATE_UNKNOWN;
|
|
1403 }
|
|
1404
|
|
1405 JabberBuddyState jabber_buddy_show_get_state(const char *id) {
|
|
1406 if(!id)
|
|
1407 return JABBER_BUDDY_STATE_UNKNOWN;
|
|
1408 if(!strcmp(id, "available"))
|
|
1409 return JABBER_BUDDY_STATE_ONLINE;
|
|
1410 if(!strcmp(id, "chat"))
|
|
1411 return JABBER_BUDDY_STATE_CHAT;
|
|
1412 if(!strcmp(id, "away"))
|
|
1413 return JABBER_BUDDY_STATE_AWAY;
|
|
1414 if(!strcmp(id, "xa"))
|
|
1415 return JABBER_BUDDY_STATE_XA;
|
|
1416 if(!strcmp(id, "dnd"))
|
|
1417 return JABBER_BUDDY_STATE_DND;
|
|
1418 if(!strcmp(id, "offline"))
|
|
1419 return JABBER_BUDDY_STATE_UNAVAILABLE;
|
|
1420 if(!strcmp(id, "error"))
|
|
1421 return JABBER_BUDDY_STATE_ERROR;
|
|
1422
|
|
1423 return JABBER_BUDDY_STATE_UNKNOWN;
|
|
1424 }
|
|
1425
|
|
1426 const char *jabber_buddy_state_get_show(JabberBuddyState state) {
|
|
1427 switch(state) {
|
|
1428 case JABBER_BUDDY_STATE_CHAT:
|
|
1429 return "chat";
|
|
1430 case JABBER_BUDDY_STATE_AWAY:
|
|
1431 return "away";
|
|
1432 case JABBER_BUDDY_STATE_XA:
|
|
1433 return "xa";
|
|
1434 case JABBER_BUDDY_STATE_DND:
|
|
1435 return "dnd";
|
|
1436 case JABBER_BUDDY_STATE_ONLINE:
|
|
1437 return "available";
|
|
1438 case JABBER_BUDDY_STATE_UNKNOWN:
|
|
1439 case JABBER_BUDDY_STATE_ERROR:
|
|
1440 return NULL;
|
|
1441 case JABBER_BUDDY_STATE_UNAVAILABLE:
|
|
1442 return "offline";
|
|
1443 }
|
|
1444 return NULL;
|
|
1445 }
|
|
1446
|
|
1447 const char *jabber_buddy_state_get_status_id(JabberBuddyState state) {
|
|
1448 switch(state) {
|
|
1449 case JABBER_BUDDY_STATE_CHAT:
|
|
1450 return "freeforchat";
|
|
1451 case JABBER_BUDDY_STATE_AWAY:
|
|
1452 return "away";
|
|
1453 case JABBER_BUDDY_STATE_XA:
|
|
1454 return "extended_away";
|
|
1455 case JABBER_BUDDY_STATE_DND:
|
|
1456 return "dnd";
|
|
1457 case JABBER_BUDDY_STATE_ONLINE:
|
|
1458 return "available";
|
|
1459 case JABBER_BUDDY_STATE_UNKNOWN:
|
|
1460 return "available";
|
|
1461 case JABBER_BUDDY_STATE_ERROR:
|
|
1462 return "error";
|
|
1463 case JABBER_BUDDY_STATE_UNAVAILABLE:
|
|
1464 return "offline";
|
|
1465 }
|
|
1466 return NULL;
|
|
1467 }
|
|
1468
|
|
1469 static void user_search_result_add_buddy_cb(GaimConnection *gc, GList *row, void *user_data)
|
|
1470 {
|
|
1471 /* XXX find out the jid */
|
|
1472 gaim_blist_request_add_buddy(gaim_connection_get_account(gc),
|
|
1473 g_list_nth_data(row, 0), NULL, NULL);
|
|
1474 }
|
|
1475
|
|
1476 static void user_search_result_cb(JabberStream *js, xmlnode *packet, gpointer data)
|
|
1477 {
|
|
1478 GaimNotifySearchResults *results;
|
|
1479 GaimNotifySearchColumn *column;
|
|
1480 xmlnode *x, *query, *item, *field;
|
|
1481
|
|
1482 /* XXX error checking? */
|
|
1483 if(!(query = xmlnode_get_child(packet, "query")))
|
|
1484 return;
|
|
1485
|
|
1486 results = gaim_notify_searchresults_new();
|
|
1487 if((x = xmlnode_get_child_with_namespace(query, "x", "jabber:x:data"))) {
|
|
1488 xmlnode *reported;
|
|
1489 gaim_debug_info("jabber", "new-skool\n");
|
|
1490 if((reported = xmlnode_get_child(x, "reported"))) {
|
|
1491 xmlnode *field = xmlnode_get_child(reported, "field");
|
|
1492 while(field) {
|
|
1493 /* XXX keep track of this order, use it below */
|
|
1494 const char *var = xmlnode_get_attrib(field, "var");
|
|
1495 const char *label = xmlnode_get_attrib(field, "label");
|
|
1496 if(var) {
|
|
1497 column = gaim_notify_searchresults_column_new(label ? label : var);
|
|
1498 gaim_notify_searchresults_column_add(results, column);
|
|
1499 }
|
|
1500 field = xmlnode_get_next_twin(field);
|
|
1501 }
|
|
1502 }
|
|
1503 item = xmlnode_get_child(x, "item");
|
|
1504 while(item) {
|
|
1505 GList *row = NULL;
|
|
1506 field = xmlnode_get_child(item, "field");
|
|
1507 while(field) {
|
|
1508 xmlnode *valuenode = xmlnode_get_child(field, "value");
|
|
1509 if(valuenode) {
|
|
1510 char *value = xmlnode_get_data(valuenode);
|
|
1511 row = g_list_append(row, value);
|
|
1512 }
|
|
1513 field = xmlnode_get_next_twin(field);
|
|
1514 }
|
|
1515 gaim_notify_searchresults_row_add(results, row);
|
|
1516
|
|
1517 item = xmlnode_get_next_twin(item);
|
|
1518 }
|
|
1519 } else {
|
|
1520 /* old skool */
|
|
1521 gaim_debug_info("jabber", "old-skool\n");
|
|
1522
|
|
1523 column = gaim_notify_searchresults_column_new(_("JID"));
|
|
1524 gaim_notify_searchresults_column_add(results, column);
|
|
1525 column = gaim_notify_searchresults_column_new(_("First Name"));
|
|
1526 gaim_notify_searchresults_column_add(results, column);
|
|
1527 column = gaim_notify_searchresults_column_new(_("Last Name"));
|
|
1528 gaim_notify_searchresults_column_add(results, column);
|
|
1529 column = gaim_notify_searchresults_column_new(_("Nickname"));
|
|
1530 gaim_notify_searchresults_column_add(results, column);
|
|
1531 column = gaim_notify_searchresults_column_new(_("E-Mail"));
|
|
1532 gaim_notify_searchresults_column_add(results, column);
|
|
1533
|
|
1534 for(item = xmlnode_get_child(query, "item"); item; item = xmlnode_get_next_twin(item)) {
|
|
1535 const char *jid;
|
|
1536 xmlnode *node;
|
|
1537 GList *row = NULL;
|
|
1538
|
|
1539 if(!(jid = xmlnode_get_attrib(item, "jid")))
|
|
1540 continue;
|
|
1541
|
|
1542 row = g_list_append(row, g_strdup(jid));
|
|
1543 node = xmlnode_get_child(item, "first");
|
|
1544 row = g_list_append(row, node ? xmlnode_get_data(node) : NULL);
|
|
1545 node = xmlnode_get_child(item, "last");
|
|
1546 row = g_list_append(row, node ? xmlnode_get_data(node) : NULL);
|
|
1547 node = xmlnode_get_child(item, "nick");
|
|
1548 row = g_list_append(row, node ? xmlnode_get_data(node) : NULL);
|
|
1549 node = xmlnode_get_child(item, "email");
|
|
1550 row = g_list_append(row, node ? xmlnode_get_data(node) : NULL);
|
|
1551 gaim_debug_info("jabber", "row=%d\n", row);
|
|
1552 gaim_notify_searchresults_row_add(results, row);
|
|
1553 }
|
|
1554 }
|
|
1555
|
|
1556 gaim_notify_searchresults_button_add(results, GAIM_NOTIFY_BUTTON_ADD,
|
|
1557 user_search_result_add_buddy_cb);
|
|
1558
|
|
1559 gaim_notify_searchresults(js->gc, NULL, NULL, _("The following are the results of your search"), results, NULL, NULL);
|
|
1560 }
|
|
1561
|
|
1562 static void user_search_x_data_cb(JabberStream *js, xmlnode *result, gpointer data)
|
|
1563 {
|
|
1564 xmlnode *query;
|
|
1565 JabberIq *iq;
|
|
1566 char *dir_server = data;
|
|
1567
|
|
1568 iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:search");
|
|
1569 query = xmlnode_get_child(iq->node, "query");
|
|
1570
|
|
1571 xmlnode_insert_child(query, result);
|
|
1572
|
|
1573 jabber_iq_set_callback(iq, user_search_result_cb, NULL);
|
|
1574 xmlnode_set_attrib(iq->node, "to", dir_server);
|
|
1575 jabber_iq_send(iq);
|
|
1576 g_free(dir_server);
|
|
1577 }
|
|
1578
|
|
1579 struct user_search_info {
|
|
1580 JabberStream *js;
|
|
1581 char *directory_server;
|
|
1582 };
|
|
1583
|
|
1584 static void user_search_cancel_cb(struct user_search_info *usi, GaimRequestFields *fields)
|
|
1585 {
|
|
1586 g_free(usi->directory_server);
|
|
1587 g_free(usi);
|
|
1588 }
|
|
1589
|
|
1590 static void user_search_cb(struct user_search_info *usi, GaimRequestFields *fields)
|
|
1591 {
|
|
1592 JabberStream *js = usi->js;
|
|
1593 JabberIq *iq;
|
|
1594 xmlnode *query;
|
|
1595 GList *groups, *flds;
|
|
1596
|
|
1597 iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:search");
|
|
1598 query = xmlnode_get_child(iq->node, "query");
|
|
1599
|
|
1600 for(groups = gaim_request_fields_get_groups(fields); groups; groups = groups->next) {
|
|
1601 for(flds = gaim_request_field_group_get_fields(groups->data);
|
|
1602 flds; flds = flds->next) {
|
|
1603 GaimRequestField *field = flds->data;
|
|
1604 const char *id = gaim_request_field_get_id(field);
|
|
1605 const char *value = gaim_request_field_string_get_value(field);
|
|
1606
|
|
1607 if(value && (!strcmp(id, "first") || !strcmp(id, "last") || !strcmp(id, "nick") || !strcmp(id, "email"))) {
|
|
1608 xmlnode *y = xmlnode_new_child(query, id);
|
|
1609 xmlnode_insert_data(y, value, -1);
|
|
1610 }
|
|
1611 }
|
|
1612 }
|
|
1613
|
|
1614 jabber_iq_set_callback(iq, user_search_result_cb, NULL);
|
|
1615 xmlnode_set_attrib(iq->node, "to", usi->directory_server);
|
|
1616 jabber_iq_send(iq);
|
|
1617
|
|
1618 g_free(usi->directory_server);
|
|
1619 g_free(usi);
|
|
1620 }
|
|
1621
|
|
1622 #if 0
|
|
1623 /* This is for gettext only -- it will see this even though there's an #if 0. */
|
|
1624
|
|
1625 /*
|
|
1626 * An incomplete list of server generated original language search
|
|
1627 * comments for Jabber User Directories
|
|
1628 *
|
|
1629 * See discussion thread "Search comment for Jabber is not translatable"
|
|
1630 * in gaim-i18n@lists.sourceforge.net (March 2006)
|
|
1631 */
|
|
1632 static const char * jabber_user_dir_comments [] = {
|
|
1633 /* current comment from Jabber User Directory users.jabber.org */
|
|
1634 N_("Find a contact by entering the search criteria in the given fields. "
|
|
1635 "Note: Each field supports wild card searches (%)"),
|
|
1636 NULL
|
|
1637 };
|
|
1638 #endif
|
|
1639
|
|
1640 static void user_search_fields_result_cb(JabberStream *js, xmlnode *packet, gpointer data)
|
|
1641 {
|
|
1642 xmlnode *query, *x;
|
|
1643 const char *from, *type;
|
|
1644
|
|
1645 if(!(from = xmlnode_get_attrib(packet, "from")))
|
|
1646 return;
|
|
1647
|
|
1648 if(!(type = xmlnode_get_attrib(packet, "type")) || !strcmp(type, "error")) {
|
|
1649 char *msg = jabber_parse_error(js, packet);
|
|
1650
|
|
1651 if(!msg)
|
|
1652 msg = g_strdup(_("Unknown error"));
|
|
1653
|
|
1654 gaim_notify_error(js->gc, _("Directory Query Failed"),
|
|
1655 _("Could not query the directory server."), msg);
|
|
1656 g_free(msg);
|
|
1657
|
|
1658 return;
|
|
1659 }
|
|
1660
|
|
1661
|
|
1662 if(!(query = xmlnode_get_child(packet, "query")))
|
|
1663 return;
|
|
1664
|
|
1665 if((x = xmlnode_get_child_with_namespace(query, "x", "jabber:x:data"))) {
|
|
1666 jabber_x_data_request(js, x, user_search_x_data_cb, g_strdup(from));
|
|
1667 return;
|
|
1668 } else {
|
|
1669 struct user_search_info *usi;
|
|
1670 xmlnode *instnode;
|
|
1671 char *instructions = NULL;
|
|
1672 GaimRequestFields *fields;
|
|
1673 GaimRequestFieldGroup *group;
|
|
1674 GaimRequestField *field;
|
|
1675
|
|
1676 /* old skool */
|
|
1677 fields = gaim_request_fields_new();
|
|
1678 group = gaim_request_field_group_new(NULL);
|
|
1679 gaim_request_fields_add_group(fields, group);
|
|
1680
|
|
1681 if((instnode = xmlnode_get_child(query, "instructions")))
|
|
1682 {
|
|
1683 char *tmp = xmlnode_get_data(instnode);
|
|
1684
|
|
1685 if(tmp)
|
|
1686 {
|
|
1687 /* Try to translate the message (see static message
|
|
1688 list in jabber_user_dir_comments[]) */
|
|
1689 instructions = g_strdup_printf(_("Server Instructions: %s"), _(tmp));
|
|
1690 g_free(tmp);
|
|
1691 }
|
|
1692 }
|
|
1693
|
|
1694 if(!instructions)
|
|
1695 {
|
|
1696 instructions = g_strdup(_("Fill in one or more fields to search "
|
|
1697 "for any matching Jabber users."));
|
|
1698 }
|
|
1699
|
|
1700 if(xmlnode_get_child(query, "first")) {
|
|
1701 field = gaim_request_field_string_new("first", _("First Name"),
|
|
1702 NULL, FALSE);
|
|
1703 gaim_request_field_group_add_field(group, field);
|
|
1704 }
|
|
1705 if(xmlnode_get_child(query, "last")) {
|
|
1706 field = gaim_request_field_string_new("last", _("Last Name"),
|
|
1707 NULL, FALSE);
|
|
1708 gaim_request_field_group_add_field(group, field);
|
|
1709 }
|
|
1710 if(xmlnode_get_child(query, "nick")) {
|
|
1711 field = gaim_request_field_string_new("nick", _("Nickname"),
|
|
1712 NULL, FALSE);
|
|
1713 gaim_request_field_group_add_field(group, field);
|
|
1714 }
|
|
1715 if(xmlnode_get_child(query, "email")) {
|
|
1716 field = gaim_request_field_string_new("email", _("E-Mail Address"),
|
|
1717 NULL, FALSE);
|
|
1718 gaim_request_field_group_add_field(group, field);
|
|
1719 }
|
|
1720
|
|
1721 usi = g_new0(struct user_search_info, 1);
|
|
1722 usi->js = js;
|
|
1723 usi->directory_server = g_strdup(from);
|
|
1724
|
|
1725 gaim_request_fields(js->gc, _("Search for Jabber users"),
|
|
1726 _("Search for Jabber users"), instructions, fields,
|
|
1727 _("Search"), G_CALLBACK(user_search_cb),
|
|
1728 _("Cancel"), G_CALLBACK(user_search_cancel_cb), usi);
|
|
1729
|
|
1730 g_free(instructions);
|
|
1731 }
|
|
1732 }
|
|
1733
|
|
1734 static void jabber_user_search_ok(JabberStream *js, const char *directory)
|
|
1735 {
|
|
1736 JabberIq *iq;
|
|
1737
|
|
1738 /* XXX: should probably better validate the directory we're given */
|
|
1739 if(!directory || !*directory) {
|
|
1740 gaim_notify_error(js->gc, _("Invalid Directory"), _("Invalid Directory"), NULL);
|
|
1741 return;
|
|
1742 }
|
|
1743
|
|
1744 iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:search");
|
|
1745 xmlnode_set_attrib(iq->node, "to", directory);
|
|
1746
|
|
1747 jabber_iq_set_callback(iq, user_search_fields_result_cb, NULL);
|
|
1748
|
|
1749 jabber_iq_send(iq);
|
|
1750 }
|
|
1751
|
|
1752 void jabber_user_search_begin(GaimPluginAction *action)
|
|
1753 {
|
|
1754 GaimConnection *gc = (GaimConnection *) action->context;
|
|
1755 JabberStream *js = gc->proto_data;
|
|
1756
|
|
1757 gaim_request_input(gc, _("Enter a User Directory"), _("Enter a User Directory"),
|
|
1758 _("Select a user directory to search"),
|
|
1759 js->user_directories ? js->user_directories->data : "users.jabber.org",
|
|
1760 FALSE, FALSE, NULL,
|
|
1761 _("Search Directory"), GAIM_CALLBACK(jabber_user_search_ok),
|
|
1762 _("Cancel"), NULL, js);
|
|
1763 }
|
|
1764
|
|
1765
|
|
1766
|