← Back to branch summary

~ubuntu-branches/ubuntu/natty/meanwhile/natty-201103250244

« back to all changes in this revision

Viewing changes to src/srvc_aware.c

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2006-01-13 12:38:18 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20060113123818-zod7j3hd9z0iz5fy
Tags: 1.0.2-0ubuntu1
* New upstream release
* Rename libmeanwhile0 to libmeanwhile1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/srvc_aware.c
113
113
  msg_OPT_GOT_SET     = 0x0259,  /**< recv attribute set update */
114
114
  msg_OPT_GOT_UNSET   = 0x025a,  /**< recv attribute unset update */
115
115
 
 
116
  msg_OPT_GOT_UNKNOWN = 0x025b,  /**< UNKNOWN */
 
117
  
116
118
  msg_OPT_DID_SET     = 0x025d,  /**< attribute set response */
117
119
  msg_OPT_DID_UNSET   = 0x025e,  /**< attribute unset response */
118
120
  msg_OPT_DID_ERROR   = 0x025f,  /**< attribute set/unset error */
141
143
 
142
144
static struct aware_entry *aware_find(struct mwServiceAware *srvc,
143
145
                                      struct mwAwareIdBlock *srch) {
144
 
  g_assert(srvc != NULL);
145
 
  g_assert(srvc->entries != NULL);
 
146
  g_return_val_if_fail(srvc != NULL, NULL);
 
147
  g_return_val_if_fail(srvc->entries != NULL, NULL);
146
148
  g_return_val_if_fail(srch != NULL, NULL);
147
149
  
148
150
  return g_hash_table_lookup(srvc->entries, srch);
171
173
  struct mwOpaque o;
172
174
  int ret;
173
175
 
 
176
  g_return_val_if_fail(chan != NULL, 0);
 
177
 
174
178
  compose_list(b, id_list);
175
179
 
176
180
  mwPutBuffer_finalize(&o, b);
187
191
  struct mwOpaque o;
188
192
  int ret;
189
193
 
 
194
  g_return_val_if_fail(chan != NULL, 0);
 
195
 
190
196
  compose_list(b, id_list);
191
197
  mwPutBuffer_finalize(&o, b);
192
198
 
249
255
  int tmp;
250
256
  GList *l;
251
257
 
 
258
  g_return_val_if_fail(srvc != NULL, -1);
 
259
  g_return_val_if_fail(srvc->channel != NULL, 0);
 
260
 
252
261
  l = map_collect_keys(srvc->attribs);
253
262
  tmp = g_list_length(l);
254
263
 
288
297
static int remove_unused_attrib(struct mwServiceAware *srvc) {
289
298
  GList *dead = NULL;
290
299
 
291
 
  if(srvc->entries) {
 
300
  if(srvc->attribs) {
292
301
    g_info("collecting dead attributes");
293
302
    g_hash_table_foreach_steal(srvc->attribs, collect_attrib_dead, &dead);
294
303
  }
298
307
    attrib_entry_free(dead->data);
299
308
  }
300
309
 
301
 
  return send_attrib_list(srvc);
 
310
  return MW_SERVICE_IS_LIVE(srvc)? send_attrib_list(srvc): 0;
302
311
}
303
312
 
304
313
 
374
383
                        struct mwAwareAttribute *attrib) {
375
384
 
376
385
  struct aware_entry *aware;
377
 
  struct mwAwareAttribute *old_attrib;
 
386
  struct mwAwareAttribute *old_attrib = NULL;
378
387
  GList *l;
379
388
  guint32 key;
380
389
  gpointer k;
385
394
  key = attrib->key;
386
395
  k = GUINT_TO_POINTER(key);
387
396
 
388
 
  old_attrib = g_hash_table_lookup(aware->attribs, k);
 
397
  if(aware->attribs)
 
398
    old_attrib = g_hash_table_lookup(aware->attribs, k);
 
399
 
389
400
  if(! old_attrib) {
390
401
    old_attrib = g_new0(struct mwAwareAttribute, 1);
391
402
    old_attrib->key = key;
399
410
    struct mwAwareList *list = l->data;
400
411
    struct mwAwareListHandler *h = list->handler;
401
412
 
402
 
    if(h && h->on_attrib && g_hash_table_lookup(list->attribs, k))
 
413
    if(h && h->on_attrib &&
 
414
       list->attribs && g_hash_table_lookup(list->attribs, k))
 
415
 
403
416
      h->on_attrib(list, idb, old_attrib);
404
417
  }
405
418
}
406
419
 
407
420
 
408
 
gboolean list_add(struct mwAwareList *list, struct mwAwareIdBlock *id) {
 
421
static gboolean list_add(struct mwAwareList *list,
 
422
                         struct mwAwareIdBlock *id) {
409
423
 
410
424
  struct mwServiceAware *srvc = list->service;
411
425
  struct aware_entry *aware;
413
427
  g_return_val_if_fail(id->user != NULL, FALSE);
414
428
  g_return_val_if_fail(strlen(id->user) > 0, FALSE);
415
429
 
 
430
  if(! list->entries)
 
431
    list->entries = g_hash_table_new((GHashFunc) mwAwareIdBlock_hash,
 
432
                                     (GEqualFunc) mwAwareIdBlock_equal);
 
433
 
416
434
  aware = list_aware_find(list, id);
417
435
  if(aware) return FALSE;
418
436
 
427
445
  }
428
446
 
429
447
  aware->membership = g_list_append(aware->membership, list);
 
448
 
430
449
  g_hash_table_insert(list->entries, ENTRY_KEY(aware), aware);
 
450
 
431
451
  return TRUE;
432
452
}
433
453
 
608
628
    recv_OPT_GOT_UNSET(srvc_aware, b);
609
629
    break;
610
630
 
 
631
  case msg_OPT_GOT_UNKNOWN:
611
632
  case msg_OPT_DID_SET:
612
633
  case msg_OPT_DID_UNSET:
613
634
  case msg_OPT_DID_ERROR:
614
635
    break;
615
636
 
616
637
  default:
617
 
    mw_debug_mailme(data, "unknown message in aware service: 0x%04x", type);   
 
638
    mw_mailme_opaque(data, "unknown message in aware service: 0x%04x", type);
618
639
  }
619
640
 
620
641
  mwGetBuffer_free(b);  
631
652
 
632
653
  g_hash_table_destroy(srvc_aware->entries);
633
654
  srvc_aware->entries = NULL;
 
655
 
 
656
  g_hash_table_destroy(srvc_aware->attribs);
 
657
  srvc_aware->attribs = NULL;
634
658
}
635
659
 
636
660
 
659
683
 
660
684
static void start(struct mwService *srvc) {
661
685
  struct mwServiceAware *srvc_aware;
662
 
  struct mwChannel *chan;
 
686
  struct mwChannel *chan = NULL;
663
687
 
664
688
  srvc_aware = (struct mwServiceAware *) srvc;
665
689
  chan = make_blist(srvc_aware, mwSession_getChannels(srvc->session));
676
700
  struct mwServiceAware *srvc_aware;
677
701
 
678
702
  srvc_aware = (struct mwServiceAware *) srvc;
679
 
  mwChannel_destroy(srvc_aware->channel, ERR_SUCCESS, NULL);
 
703
 
 
704
  if(srvc_aware->channel) {
 
705
    mwChannel_destroy(srvc_aware->channel, ERR_SUCCESS, NULL);
 
706
    srvc_aware->channel = NULL;
 
707
  }
 
708
 
680
709
  mwService_stopped(srvc);
681
710
}
682
711
 
702
731
                                        (GDestroyNotify) attrib_entry_free);
703
732
 
704
733
  service = MW_SERVICE(srvc);
705
 
  mwService_init(service, session, SERVICE_AWARE);
 
734
  mwService_init(service, session, mwService_AWARE);
706
735
 
707
736
  service->recv_accept = (mwService_funcRecvAccept) recv_accept;
708
737
  service->recv_destroy = (mwService_funcRecvDestroy) recv_destroy;
913
942
 
914
943
  al = g_new0(struct mwAwareList, 1);
915
944
  al->service = srvc;
916
 
  al->entries = g_hash_table_new((GHashFunc) mwAwareIdBlock_hash,
917
 
                                 (GEqualFunc) mwAwareIdBlock_equal);
918
 
  al->attribs = g_hash_table_new(g_direct_hash, g_direct_equal);
919
945
  al->handler = handler;
920
946
 
 
947
  srvc->lists = g_list_prepend(srvc->lists, al);
 
948
 
921
949
  return al;
922
950
}
923
951
 
927
955
  struct mwAwareListHandler *handler;
928
956
 
929
957
  g_return_if_fail(list != NULL);
930
 
  g_return_if_fail(list->entries != NULL);
931
958
  g_return_if_fail(list->service != NULL);
932
959
 
 
960
  srvc = list->service;
 
961
  srvc->lists = g_list_remove_all(srvc->lists, list);
 
962
 
933
963
  handler = list->handler;
934
964
  if(handler && handler->clear) {
935
965
    handler->clear(list);
938
968
 
939
969
  mw_datum_clear(&list->client_data);
940
970
 
941
 
  srvc = list->service;
942
 
  srvc->lists = g_list_remove(srvc->lists, list);
943
 
 
944
971
  mwAwareList_unwatchAllAttributes(list);
945
972
  mwAwareList_removeAllAware(list);
 
973
 
 
974
  list->service = NULL;
 
975
 
 
976
  g_free(list);
946
977
}
947
978
 
948
979
 
957
988
  struct attrib_entry *watch;
958
989
  gpointer k = GUINT_TO_POINTER(key);
959
990
 
 
991
  if(! list->attribs)
 
992
    list->attribs = g_hash_table_new(g_direct_hash, g_direct_equal);
 
993
 
960
994
  if(g_hash_table_lookup(list->attribs, k))
961
995
    return;
962
996
 
970
1004
  }
971
1005
 
972
1006
  g_hash_table_insert(list->attribs, k, watch);
 
1007
 
973
1008
  watch->membership = g_list_prepend(watch->membership, list);
974
1009
}
975
1010
 
976
1011
 
977
1012
static void watch_remove(struct mwAwareList *list, guint32 key) {
978
 
  struct attrib_entry *watch;
 
1013
  struct attrib_entry *watch = NULL;
979
1014
  gpointer k = GUINT_TO_POINTER(key);
980
1015
 
981
 
  watch = g_hash_table_lookup(list->attribs, k);
 
1016
  if(list->attribs)
 
1017
    watch = g_hash_table_lookup(list->attribs, k);
 
1018
 
982
1019
  g_return_if_fail(watch != NULL);
983
1020
 
984
1021
  g_hash_table_remove(list->attribs, k);
1031
1068
  for(k = *keys; k; keys++)
1032
1069
    watch_add(list, k);
1033
1070
 
1034
 
  remove_unused_attrib(list->service);
1035
 
  return send_attrib_list(list->service);
 
1071
  return remove_unused_attrib(list->service);
1036
1072
}
1037
1073
 
1038
1074
 
1049
1085
    watch_remove(list, k);
1050
1086
  va_end(args);
1051
1087
 
1052
 
  remove_unused_attrib(list->service);
1053
 
  return send_attrib_list(list->service);
 
1088
  return remove_unused_attrib(list->service);
1054
1089
}
1055
1090
 
1056
1091
 
1068
1103
  g_return_val_if_fail(list != NULL, -1);
1069
1104
  srvc = list->service;
1070
1105
 
1071
 
  g_hash_table_foreach(list->attribs, (GHFunc) dismember_attrib, list);
1072
 
  g_hash_table_destroy(list->attribs);
1073
 
  list->attribs = g_hash_table_new(g_direct_hash, g_direct_equal);
 
1106
  if(list->attribs) {
 
1107
    g_hash_table_foreach(list->attribs, (GHFunc) dismember_attrib, list);
 
1108
    g_hash_table_destroy(list->attribs);
 
1109
  }
1074
1110
 
1075
 
  remove_unused_attrib(srvc);
1076
 
  return send_attrib_list(list->service);
 
1111
  return remove_unused_attrib(srvc);
1077
1112
}
1078
1113
 
1079
1114
 
1191
1226
 
1192
1227
  /* for each entry, remove the aware list from the service entry's
1193
1228
     membership collection */
1194
 
  g_hash_table_foreach(list->entries, (GHFunc) dismember_aware, list);
1195
 
  g_hash_table_destroy(list->entries);
1196
 
  g_free(list);
 
1229
  if(list->entries) {
 
1230
    g_hash_table_foreach(list->entries, (GHFunc) dismember_aware, list);
 
1231
    g_hash_table_destroy(list->entries);
 
1232
  }
1197
1233
 
1198
1234
  return remove_unused(srvc);
1199
1235
}
1275
1311
  g_return_val_if_fail(user != NULL, NULL);
1276
1312
 
1277
1313
  aware = aware_find(srvc, user);
1278
 
  g_return_val_if_fail(aware != NULL, NULL);
 
1314
  if(! aware) return NULL;
1279
1315
 
1280
1316
  return aware->aware.status.desc;
1281
1317
}