← Back to branch summary

~ubuntu-branches/ubuntu/vivid/liferea/vivid-proposed

« back to all changes in this revision

Viewing changes to src/sync/avahi_browser.c

  • Committer: Package Import Robot
  • Author(s): bojo42
  • Date: 2012-03-29 14:17:21 UTC
  • mfrom: (1.3.9) (3.2.5 sid)
  • Revision ID: package-import@ubuntu.com-20120329141721-tbfopcrc5797wxt7
Tags: 1.8.3-0.1ubuntu1
https://launchpad.net/bugs/290666
https://launchpad.net/bugs/371754
https://launchpad.net/bugs/741543
https://launchpad.net/bugs/716688
https://launchpad.net/bugs/935147
* New upstream release (LP: #290666, #371754, #741543, #716688)
* Merge from Debian unstable (LP: #935147), remaining changes:
* debian/patches:
  - drop gtk-status-icon.patch & notification-append as in upstream
  - drop fix_systray_behavior as mostly upstreamed and rest seems unused
  - 01_ubuntu_feedlists: update & rename, move planets to "Open Source"  
  - add_X-Ubuntu-Gettext-Domain: rebase
  - libunity.patch: rebase, apply before indicator patch (liferea_shell.c)
  - libindicate_increase_version.patch: exclude from libindicate.patch
  - deactivate libindicate.patch, seems partly upstreamed and needs rework
* debian/control: libindicate-dev, libindicate-gtk-dev & libunity-dev
* debian/liferea.indicate & liferea.install: ship indicator desktop file
* debian/rules: enable libindicate

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sync/avahi_browser.c
1
 
/**
2
 
 * @file avahi_browser.c  cache synchronization using AVAHI
3
 
 * 
4
 
 * Copyright (C) 2007 Lars Lindner <lars.lindner@gmail.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 "sync/avahi_browser.h"
22
 
#include "conf.h"
23
 
 
24
 
#include <glib.h>
25
 
#include <glib/gi18n.h>
26
 
#include <glib-object.h>
27
 
 
28
 
#include <avahi-client/lookup.h>
29
 
#include <avahi-client/publish.h>
30
 
#include <avahi-client/client.h>
31
 
#include <avahi-common/error.h>
32
 
#include <avahi-glib/glib-malloc.h>
33
 
#include <avahi-glib/glib-watch.h>
34
 
 
35
 
static void liferea_avahi_browser_class_init    (LifereaAvahiBrowserClass *klass);
36
 
static void liferea_avahi_browser_init  (LifereaAvahiBrowser    *browser);
37
 
static void liferea_avahi_browser_finalize      (GObject *object);
38
 
 
39
 
#define LIFEREA_AVAHI_BROWSER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), LIFEREA_AVAHI_BROWSER_TYPE, LifereaAvahiBrowserPrivate))
40
 
 
41
 
struct LifereaAvahiBrowserPrivate {
42
 
        AvahiClient             *client;
43
 
        AvahiGLibPoll           *poll;
44
 
        AvahiServiceBrowser     *serviceBrowser;
45
 
        
46
 
        GSList                  *resolvers;
47
 
};
48
 
 
49
 
enum {
50
 
        SERVICE_ADDED,
51
 
        SERVICE_REMOVED,
52
 
        LAST_SIGNAL
53
 
};
54
 
 
55
 
enum {
56
 
        PROP_0
57
 
};
58
 
 
59
 
//static guint       signals [LAST_SIGNAL] = { 0, };
60
 
static GObjectClass *parent_class = NULL;
61
 
 
62
 
static gpointer liferea_avahi_browser = NULL;
63
 
 
64
 
GQuark
65
 
liferea_avahi_browser_error_quark (void)
66
 
{
67
 
        static GQuark quark = 0;
68
 
        if (!quark)
69
 
                quark = g_quark_from_static_string ("liferea_avahi_browser_error");
70
 
 
71
 
        return quark;
72
 
}
73
 
 
74
 
static void
75
 
client_cb (AvahiClient         *client,
76
 
           AvahiClientState     state,
77
 
           LifereaAvahiBrowser *browser)
78
 
{
79
 
        /* Called whenever the client or server state changes */
80
 
 
81
 
        switch (state) {
82
 
        case AVAHI_CLIENT_FAILURE:
83
 
                g_warning ("Client failure: %s\n", avahi_strerror (avahi_client_errno (client)));
84
 
                break;
85
 
        default:
86
 
                break;
87
 
        }
88
 
}
89
 
 
90
 
static void
91
 
avahi_client_init (LifereaAvahiBrowser *browser)
92
 
{
93
 
        gint error = 0;
94
 
 
95
 
        avahi_set_allocator (avahi_glib_allocator ());
96
 
 
97
 
        browser->priv->poll = avahi_glib_poll_new (NULL, G_PRIORITY_DEFAULT);
98
 
 
99
 
        if (!browser->priv->poll)
100
 
                g_warning ("Unable to create AvahiGlibPoll object for mDNS");
101
 
 
102
 
        AvahiClientFlags flags;
103
 
        flags = 0;
104
 
 
105
 
        browser->priv->client = avahi_client_new (avahi_glib_poll_get (browser->priv->poll),
106
 
                                                    flags,
107
 
                                                    (AvahiClientCallback)client_cb,
108
 
                                                    browser,
109
 
                                                    &error);
110
 
}
111
 
 
112
 
/*static void
113
 
resolve_cb (AvahiServiceResolver  *service_resolver,
114
 
            AvahiIfIndex           interface,
115
 
            AvahiProtocol          protocol,
116
 
            AvahiResolverEvent     event,
117
 
            const char            *service_name,
118
 
            const char            *type,
119
 
            const char            *domain,
120
 
            const char            *host_name,
121
 
            const AvahiAddress    *address,
122
 
            uint16_t               port,
123
 
            AvahiStringList       *text,
124
 
            AvahiLookupResultFlags flags,
125
 
            LifereaAvahiBrowser    *browser)
126
 
{
127
 
        if (event == AVAHI_RESOLVER_FOUND) {
128
 
                char    *name = NULL;
129
 
                char     host [AVAHI_ADDRESS_STR_MAX];
130
 
                gboolean pp = FALSE;
131
 
 
132
 
                if (text) {
133
 
                        AvahiStringList *l;
134
 
 
135
 
                        for (l = text; l != NULL; l = l->next) {
136
 
                                size_t size;
137
 
                                char  *key;
138
 
                                char  *value;
139
 
                                int    ret;
140
 
 
141
 
                                ret = avahi_string_list_get_pair (l, &key, &value, &size);
142
 
                                if (ret != 0 || key == NULL) {
143
 
                                        continue;
144
 
                                }
145
 
 
146
 
                                if (strcmp (key, "Password") == 0) {
147
 
                                        if (size >= 4 && strncmp (value, "true", 4) == 0) {
148
 
                                                pp = TRUE;
149
 
                                        }
150
 
                                } else if (strcmp (key, "Machine Name") == 0) {
151
 
                                        name = g_strdup (value);
152
 
                                }
153
 
 
154
 
                                g_free (key);
155
 
                                g_free (value);
156
 
                        }
157
 
                }
158
 
 
159
 
                if (name == NULL) {
160
 
                        name = g_strdup (service_name);
161
 
                }
162
 
 
163
 
                avahi_address_snprint (host, AVAHI_ADDRESS_STR_MAX, address);
164
 
 
165
 
                g_signal_emit (browser,
166
 
                               signals [SERVICE_ADDED],
167
 
                               0,
168
 
                               service_name,
169
 
                               name,
170
 
                               host,
171
 
                               port,
172
 
                               pp);
173
 
 
174
 
                g_free (name);
175
 
        }
176
 
 
177
 
        browser->priv->resolvers = g_slist_remove (browser->priv->resolvers, service_resolver);
178
 
        avahi_service_resolver_free (service_resolver);
179
 
}*/
180
 
 
181
 
/*static gboolean
182
 
liferea_avahi_browser_resolve (LifereaAvahiBrowser *browser,
183
 
                               const char         *name)
184
 
{
185
 
        AvahiServiceResolver *service_resolver;
186
 
 
187
 
        service_resolver = avahi_service_resolver_new (browser->priv->client,
188
 
                                                       AVAHI_IF_UNSPEC,
189
 
                                                       AVAHI_PROTO_INET,
190
 
                                                       name,
191
 
                                                       "_liferea._tcp",
192
 
                                                       NULL,
193
 
                                                       AVAHI_PROTO_UNSPEC,
194
 
                                                       0,
195
 
                                                       (AvahiServiceResolverCallback)resolve_cb,
196
 
                                                       browser);
197
 
        if (service_resolver == NULL) {
198
 
                rb_debug ("Error starting mDNS resolving using AvahiServiceResolver");
199
 
                return FALSE;
200
 
        }
201
 
 
202
 
        browser->priv->resolvers = g_slist_prepend (browser->priv->resolvers, service_resolver);
203
 
 
204
 
        return TRUE;
205
 
}*/
206
 
 
207
 
void
208
 
liferea_avahi_browser_start (LifereaAvahiBrowser *browser)
209
 
{
210
 
}
211
 
 
212
 
void
213
 
liferea_avahi_browser_stop (LifereaAvahiBrowser *browser)
214
 
{
215
 
}
216
 
 
217
 
GType
218
 
liferea_avahi_browser_get_type (void) 
219
 
{
220
 
        static GType type = 0;
221
 
 
222
 
        if (G_UNLIKELY (type == 0)) 
223
 
        {
224
 
                static const GTypeInfo our_info = 
225
 
                {
226
 
                        sizeof (LifereaAvahiBrowserClass),
227
 
                        NULL, /* base_init */
228
 
                        NULL, /* base_finalize */
229
 
                        (GClassInitFunc) liferea_avahi_browser_class_init,
230
 
                        NULL,
231
 
                        NULL, /* class_data */
232
 
                        sizeof (LifereaAvahiBrowser),
233
 
                        0, /* n_preallocs */
234
 
                        (GInstanceInitFunc) liferea_avahi_browser_init
235
 
                };
236
 
 
237
 
                type = g_type_register_static (G_TYPE_OBJECT,
238
 
                                               "LifereaAvahiBrowser",
239
 
                                               &our_info, 0);
240
 
        }
241
 
 
242
 
        return type;
243
 
}
244
 
 
245
 
static void
246
 
liferea_avahi_browser_class_init (LifereaAvahiBrowserClass *klass)
247
 
{
248
 
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
249
 
 
250
 
        parent_class = g_type_class_peek_parent (klass);
251
 
 
252
 
        object_class->finalize = liferea_avahi_browser_finalize;
253
 
 
254
 
        g_type_class_add_private (object_class, sizeof(LifereaAvahiBrowserPrivate));
255
 
}
256
 
 
257
 
static void
258
 
liferea_avahi_browser_init (LifereaAvahiBrowser *browser)
259
 
{
260
 
        browser->priv = LIFEREA_AVAHI_BROWSER_GET_PRIVATE (browser);
261
 
        
262
 
        avahi_client_init (browser);
263
 
}
264
 
 
265
 
static void
266
 
liferea_avahi_browser_finalize (GObject *object)
267
 
{
268
 
        LifereaAvahiBrowser *browser;
269
 
        
270
 
        browser = LIFEREA_AVAHI_BROWSER (object);
271
 
        
272
 
        g_return_if_fail (browser->priv != NULL);
273
 
        
274
 
/*      if (browser->priv->entry_group)
275
 
                avahi_entry_group_free (browser->priv->entry_group);
276
 
        */      
277
 
        if (browser->priv->client)
278
 
                avahi_client_free (browser->priv->client);
279
 
                
280
 
        if (browser->priv->poll)
281
 
                avahi_glib_poll_free (browser->priv->poll);
282
 
                
283
 
//      g_free (browser->priv->name);
284
 
        
285
 
        G_OBJECT_CLASS (parent_class)->finalize (object);
286
 
}
287
 
 
288
 
LifereaAvahiBrowser *
289
 
liferea_avahi_browser_new (void)
290
 
{
291
 
        gchar   *serviceName;
292
 
        
293
 
        /* check service name preference and set default if necessary */
294
 
        serviceName = conf_get_str_value (SYNC_AVAHI_SERVICE_NAME);
295
 
        if (g_str_equal (serviceName, "")) {
296
 
                g_free (serviceName);
297
 
                serviceName = g_strdup_printf (_("Liferea Sync %s@%s"), g_get_user_name(), g_get_host_name ());
298
 
                conf_set_str_value (SYNC_AVAHI_SERVICE_NAME, serviceName);
299
 
        }
300
 
        g_free (serviceName);
301
 
 
302
 
        if (liferea_avahi_browser) {
303
 
                g_object_ref (liferea_avahi_browser);
304
 
        } else {
305
 
                liferea_avahi_browser = g_object_new (LIFEREA_AVAHI_BROWSER_TYPE, NULL);
306
 
                g_object_add_weak_pointer (liferea_avahi_browser, (gpointer *) &liferea_avahi_browser);
307
 
        }
308
 
        
309
 
        return liferea_avahi_browser;
310
 
}