Network Menu

Merge lp:~kvalo/indicator-network/libconnman-service-properties into lp:~indicator-applet-developers/indicator-network/indicator-network

  1. libconnman-service-properties
  2. Merge into indicator-network
Proposed by Kalle Valo
Status: Merged
Merged at revision: 139
Proposed branch: lp:~kvalo/indicator-network/libconnman-service-properties
Merge into: lp:~indicator-applet-developers/indicator-network/indicator-network
Diff against target: 1585 lines (+1135/-62)
13 files modified
Makefile.am (+4/-0)
data/Makefile.am (+2/-1)
data/ok-banner (+9/-0)
src/backend/service.c (+1/-1)
src/libconnman/Connman-1.0.vapi (+96/-1)
src/libconnman/Makefile.am (+2/-1)
src/libconnman/connman-manager.c (+2/-0)
src/libconnman/connman-service.c (+848/-45)
src/libconnman/connman-service.h (+26/-1)
src/libconnman/connman.h (+14/-0)
tests/libconnman-tool.c (+2/-2)
tests/libconnman-vala/libconnman-vala.vala (+128/-9)
tests/mock-connman-service.c (+1/-1)
To merge this branch: bzr merge lp:~kvalo/indicator-network/libconnman-service-properties
Reviewer Review Type Date Requested Status
Mikkel Kamstrup Erlandsen (community) Approve
Review via email: mp+48034@code.launchpad.net

Description of the change

First shot at vala bindings for libconnman.

To post a comment you must log in.
Revision history for this message
Mikkel Kamstrup Erlandsen (kamstrup) wrote :
Download full text (3.3 KiB)

I didn't spot any errors as such, but there are some sections that can be simplified a great deal so marking as needsfixing. But really good work I must say.

313 +void connman_service_set_passphrase(ConnmanService *self,
314 + const gchar *passphrase)
315 +{
316 + ConnmanServicePrivate *priv = GET_PRIVATE(self);
317 + GValue value = {0};
318 +
319 + g_return_if_fail(CONNMAN_IS_SERVICE(self));
320 + g_return_if_fail(priv != NULL);
321 +
322 + g_value_init(&value, G_TYPE_STRING);
323 + g_value_set_string(&value, passphrase);
324 +
325 + g_object_set_property(G_OBJECT(self), "passphrase", &value);
326 +
327 + g_value_unset(&value);
328 +}

Considering all places you apply this pattern - you can do this a lot easier in 1 of 2 ways:

1)
  const gchar *newval;
  priv->stringprop = g_strup (newval);
  g_object_notify (self, "stringprop");

2)
  const gchar *newval;
  g_object_set (self, "stringprop", newval, NULL);

580 +void connman_service_set_domains_configuration(ConnmanService *self,
581 + gchar **domains)
582 +{
583 + ConnmanServicePrivate *priv = GET_PRIVATE(self);
584 + GValue value = {0};
585 + gchar **array;
586 + guint i, len;
587 +
588 + g_return_if_fail(CONNMAN_IS_SERVICE(self));
589 + g_return_if_fail(priv != NULL);
590 +
591 + /* FIXME: figure out and _document_ how to clear the domains */
592 + if (domains == NULL)
593 + return;
594 +
595 + len = g_strv_length(domains);
596 +
597 + array = g_new0(gchar *, len + 1);
598 +
599 + for (i = 0; i < len; i++)
600 + array[i] = g_strdup(domains[i]);
601 +
602 + array[len] = NULL;
603 +
604 + g_value_init(&value, G_TYPE_STRV);
605 + g_value_take_boxed(&value, array);
606 +
607 + g_object_set_property(G_OBJECT(self), "domains-configuration", &value);
608 +
609 + g_value_unset(&value);
610 +}

Why not use g_strdupv()? Or just g_value_set_boxed(&value, domains); Or even simpler g_object_set (self, "domains-configuration", domains, NULL); ? ;-) (this works because you have registered a boxed pspec of G_TYPE_STRV)

And some C nitpickery... The 'gchar**' you pass around are really 'const gchar* const*' - not saying you have to use this signature, but I personally like being anal with that :-)

811 +static void nameservers_updated(ConnmanService *self, GVariant *variant)
812 +{
813 + ConnmanServicePrivate *priv = GET_PRIVATE(self);
814 + GVariantIter iter;
815 + gchar **array, *server;
816 + guint i;
817 +
818 + g_strfreev(priv->nameservers);
819 +
820 + g_variant_iter_init(&iter, variant);
821 + i = 0;
822 + array = g_new0(char *, MAX_NAMESERVERS);
823 +
824 + while (g_variant_iter_next(&iter, "s", &server)) {
825 + array[i] = server;
826 + i++;
827 + if (i >= MAX_NAMESERVERS) {
828 + g_warning("libconnman: nameserver limit reached!");
829 + break;
830 + }
831 + }
832 +
833 + if (i == 0) {
834 + g_free(array);
835 + array = NULL;
836 + }
837 +
838 + priv->nameservers = array;
839 + g_object_notify(G_OBJECT(self), "nameservers");
840 +
841 + g_variant_unref(variant);
842 +}

g_variant_get_strv()?

And no need to prefix the g_warning() if you define a log domian on compile time. Something like -DG_LOG_DOMAIN=\"libconnman\"

1548 +static string list2str(string[] list) {
1549 + var result = "";
1550 +...

Read more...

review: Needs Fixing
lp:~kvalo/indicator-network/libconnman-service-properties updated
156. By Kalle Valo

libconnman: set log domain

No need to set "libconnman:" manually.

157. By Kalle Valo

connman-service: use g_object_set() instead of set_property()

Reduces a lot of code.

158. By Kalle Valo

connman-service: use g_variant_dup_strv()

159. By Kalle Valo

libconnman-vala: use string.joinv()

Revision history for this message
Kalle Valo (kvalo) wrote :
Download full text (4.5 KiB)

Mikkel Kamstrup Erlandsen <email address hidden> writes:

> Review: Needs Fixing I didn't spot any errors as such, but there are
> some sections that can be simplified a great deal so marking as
> needsfixing.

Oh yes, I agree. Your suggestions remove a lot of code, which is always
a good thing.

> 313 +void connman_service_set_passphrase(ConnmanService *self,
> 314 + const gchar *passphrase)
> 315 +{
> 316 + ConnmanServicePrivate *priv = GET_PRIVATE(self);
> 317 + GValue value = {0};
> 318 +
> 319 + g_return_if_fail(CONNMAN_IS_SERVICE(self));
> 320 + g_return_if_fail(priv != NULL);
> 321 +
> 322 + g_value_init(&value, G_TYPE_STRING);
> 323 + g_value_set_string(&value, passphrase);
> 324 +
> 325 + g_object_set_property(G_OBJECT(self), "passphrase", &value);
> 326 +
> 327 + g_value_unset(&value);
> 328 +}
>
> Considering all places you apply this pattern - you can do this a lot
> easier in 1 of 2 ways:
>
> 1)
> const gchar *newval;
> priv->stringprop = g_strup (newval);
> g_object_notify (self, "stringprop");
>
> 2)
> const gchar *newval;
> g_object_set (self, "stringprop", newval, NULL);

Oh man, I didn't know that g_object_set() can take the original
variable. I was under impression that it wants a gvalue :/

I chose option two because it was smaller :)

> 580 +void connman_service_set_domains_configuration(ConnmanService *self,
> 581 + gchar **domains)
> 582 +{
> 583 + ConnmanServicePrivate *priv = GET_PRIVATE(self);
> 584 + GValue value = {0};
> 585 + gchar **array;
> 586 + guint i, len;
> 587 +
> 588 + g_return_if_fail(CONNMAN_IS_SERVICE(self));
> 589 + g_return_if_fail(priv != NULL);
> 590 +
> 591 + /* FIXME: figure out and _document_ how to clear the domains */
> 592 + if (domains == NULL)
> 593 + return;
> 594 +
> 595 + len = g_strv_length(domains);
> 596 +
> 597 + array = g_new0(gchar *, len + 1);
> 598 +
> 599 + for (i = 0; i < len; i++)
> 600 + array[i] = g_strdup(domains[i]);
> 601 +
> 602 + array[len] = NULL;
> 603 +
> 604 + g_value_init(&value, G_TYPE_STRV);
> 605 + g_value_take_boxed(&value, array);
> 606 +
> 607 + g_object_set_property(G_OBJECT(self), "domains-configuration", &value);
> 608 +
> 609 + g_value_unset(&value);
> 610 +}
>
> Why not use g_strdupv()? Or just g_value_set_boxed(&value, domains);
> Or even simpler g_object_set (self, "domains-configuration", domains,
> NULL); ? ;-) (this works because you have registered a boxed pspec of
> G_TYPE_STRV)

I decided to use g_object_set(). I so wish the function had been documented
better, that would have saved some time :)

> And some C nitpickery... The 'gchar**' you pass around are really
> 'const gchar* const*' - not saying you have to use this signature, but
> I personally like being anal with that :-)

Actually I first had 'const gchar *', but compiler and/or vala was
complaining something (I can't remember what anymore) so I just took a
shortcut here. But at some point I'll definitely try to use 'const gchar
* const *'. Thanks for the tip.

> 811 +static void nameservers_updated(ConnmanService *self, GVariant *variant)
> 812 +{
> 813 + ConnmanServicePrivate *priv = GET_PRIVATE(self);
> 814 + GVariantIter iter;
> 815 + gchar **array, *server;
> 816 + gui...

Read more...

Revision history for this message
Mikkel Kamstrup Erlandsen (kamstrup) wrote :

Awesome work Kalle!

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'Makefile.am'
2--- Makefile.am 2011-01-26 08:20:34 +0000
3+++ Makefile.am 2011-02-01 08:44:09 +0000
4@@ -9,3 +9,7 @@
5 EXTRA_DIST = autogen.sh
6
7 DISTCHECK_CONFIGURE_FLAGS = --enable-localinstall
8+
9+# don't know how to print the banner otherwise than dumping it from a file
10+allchecks: all check distcheck
11+ @cat $(srcdir)/data/ok-banner
12
13=== modified file 'data/Makefile.am'
14--- data/Makefile.am 2010-12-09 08:56:50 +0000
15+++ data/Makefile.am 2011-02-01 08:44:09 +0000
16@@ -11,7 +11,8 @@
17 # sed -e "s|\@libexecdir\@|$(libexecdir)|" $< > $@
18
19 EXTRA_DIST = \
20- $(service_in_files)
21+ $(service_in_files) \
22+ ok-banner
23
24 CLEANFILES = \
25 $(dbus_services_DATA)
26
27=== added file 'data/ok-banner'
28--- data/ok-banner 1970-01-01 00:00:00 +0000
29+++ data/ok-banner 2011-02-01 08:44:09 +0000
30@@ -0,0 +1,9 @@
31+
32+**********************************************************************
33+ ___ _ ___
34+ / _ \| |/ / |
35+| | | | ' /| |
36+| |_| | . \|_|
37+ \___/|_|\_(_) No errors found
38+
39+**********************************************************************
40
41=== modified file 'src/backend/service.c'
42--- src/backend/service.c 2010-11-30 13:31:06 +0000
43+++ src/backend/service.c 2011-02-01 08:44:09 +0000
44@@ -514,7 +514,7 @@
45 G_CALLBACK(strength_updated),
46 self);
47
48- if (connman_service_is_setup_required(priv->service))
49+ if (connman_service_get_setup_required(priv->service))
50 setup_required(self);
51
52 return self;
53
54=== modified file 'src/libconnman/Connman-1.0.vapi'
55--- src/libconnman/Connman-1.0.vapi 2011-01-13 21:35:09 +0000
56+++ src/libconnman/Connman-1.0.vapi 2011-02-01 08:44:09 +0000
57@@ -31,31 +31,72 @@
58 public Service (string path);
59 public async void connect () throws GLib.Error;
60 public async void disconnect () throws GLib.Error;
61+ public unowned string get_apn ();
62+ [CCode (array_length = false, array_null_terminated = true)]
63+ public unowned string[] get_domains ();
64+ [CCode (array_length = false, array_null_terminated = true)]
65+ public unowned string[] get_domains_configuration ();
66+ public bool get_autoconnect ();
67 public unowned string get_error ();
68+ public bool get_favorite ();
69+ public bool get_immutable ();
70+ public bool get_login_required ();
71+ public unowned string get_mcc ();
72+ public unowned string get_mnc ();
73 public unowned string get_name ();
74+ [CCode (array_length = false, array_null_terminated = true)]
75+ public unowned string[] get_nameservers ();
76+ [CCode (array_length = false, array_null_terminated = true)]
77+ public unowned string[] get_nameservers_configuration ();
78+ public unowned string get_passphrase ();
79+ public bool get_passphrase_required ();
80 public unowned string get_path ();
81+ public bool get_roaming ();
82 public Connman.ServiceSecurity get_security ();
83 public Connman.ServiceType get_service_type ();
84+ public bool get_setup_required ();
85 public Connman.ServiceState get_state ();
86 public uint8 get_strength ();
87 public bool is_ready ();
88- public bool is_setup_required ();
89 public static unowned string mode2str (Connman.ServiceMode mode);
90 public static unowned string security2str (Connman.ServiceSecurity security);
91+ public void set_apn (string apn);
92+ public void set_autoconnect (bool autoconnect);
93+ public void set_domains_configuration ([CCode (array_length = false, array_null_terminated = true)] string[] domains);
94+ public void set_nameservers_configuration ([CCode (array_length = false, array_null_terminated = true)] string[] nameservers);
95+ public void set_passphrase (string passphrase);
96 public static unowned string state2str (Connman.ServiceState state);
97 public static Connman.ServiceMode str2mode (string mode);
98 public static Connman.ServiceSecurity str2security (string security);
99 public static Connman.ServiceState str2state (string state);
100 public static Connman.ServiceType str2type (string type);
101 public static unowned string type2str (Connman.ServiceType type);
102+ public string apn { get; set; }
103+ public bool autoconnect { get; set; }
104+ public string[] domains { get; }
105+ public string[] domains_configuration { get; set; }
106 public string error { get; }
107+ public bool favorite { get; }
108+ public bool immutable { get; }
109+ public bool login_required { get; }
110+ public string mcc { get; }
111+ public string mnc { get; }
112+ [NoAccessorMethod]
113+ public uint mode { get; }
114 public string name { get; }
115+ public string[] nameservers { get; }
116+ public string[] nameservers_configuration { get; set; }
117+ public string passphrase { get; set; }
118+ public bool passphrase_required { get; }
119 public string path { get; construct; }
120+ [NoAccessorMethod]
121 public bool ready { get; }
122+ public bool roaming { get; }
123 public uint security { get; }
124 public bool setup_required { get; }
125 public uint state { get; }
126 public uint strength { get; }
127+ [NoAccessorMethod]
128 public uint type { get; }
129 }
130 [CCode (cprefix = "CONNMAN_SERVICE_MODE_", cheader_filename = "connman-service.h")]
131@@ -88,4 +129,58 @@
132 BLUETOOTH,
133 CELLULAR
134 }
135+ [CCode (cheader_filename = "connman-service.h")]
136+ public const string MANAGER_PATH;
137+ [CCode (cheader_filename = "connman-service.h")]
138+ public const string PATH;
139+ [CCode (cheader_filename = "connman-service.h")]
140+ public const string PROPERTY_DEFAULT_TECHNOLOGY;
141+ [CCode (cheader_filename = "connman-service.h")]
142+ public const string PROPERTY_ENABLED_TECHNOLOGIES;
143+ [CCode (cheader_filename = "connman-service.h")]
144+ public const string PROPERTY_ERROR;
145+ [CCode (cheader_filename = "connman-service.h")]
146+ public const string PROPERTY_NAME;
147+ [CCode (cheader_filename = "connman-service.h")]
148+ public const string PROPERTY_PASSPHRASE;
149+ [CCode (cheader_filename = "connman-service.h")]
150+ public const string PROPERTY_SECURITY;
151+ [CCode (cheader_filename = "connman-service.h")]
152+ public const string PROPERTY_SERVICES;
153+ [CCode (cheader_filename = "connman-service.h")]
154+ public const string PROPERTY_SETUP_REQUIRED;
155+ [CCode (cheader_filename = "connman-service.h")]
156+ public const string PROPERTY_STATE;
157+ [CCode (cheader_filename = "connman-service.h")]
158+ public const string PROPERTY_STRENGTH;
159+ [CCode (cheader_filename = "connman-service.h")]
160+ public const string PROPERTY_TYPE;
161+ [CCode (cheader_filename = "connman-service.h")]
162+ public const string SECURITY_NONE;
163+ [CCode (cheader_filename = "connman-service.h")]
164+ public const string SECURITY_PSK;
165+ [CCode (cheader_filename = "connman-service.h")]
166+ public const string SECURITY_RSN;
167+ [CCode (cheader_filename = "connman-service.h")]
168+ public const string SECURITY_WEP;
169+ [CCode (cheader_filename = "connman-service.h")]
170+ public const string SECURITY_WPA;
171+ [CCode (cheader_filename = "connman-service.h")]
172+ public const string SERVICE_NAME;
173+ [CCode (cheader_filename = "connman-service.h")]
174+ public const string SIGNAL_PROPERTY_CHANGED;
175+ [CCode (cheader_filename = "connman-service.h")]
176+ public const string STATE_CONNECTING;
177+ [CCode (cheader_filename = "connman-service.h")]
178+ public const string STATE_OFFLINE;
179+ [CCode (cheader_filename = "connman-service.h")]
180+ public const string STATE_ONLINE;
181+ [CCode (cheader_filename = "connman-service.h")]
182+ public const string TECHNOLOGY_BLUETOOTH;
183+ [CCode (cheader_filename = "connman-service.h")]
184+ public const string TECHNOLOGY_CELLULAR;
185+ [CCode (cheader_filename = "connman-service.h")]
186+ public const string TECHNOLOGY_ETHERNET;
187+ [CCode (cheader_filename = "connman-service.h")]
188+ public const string TECHNOLOGY_WIFI;
189 }
190
191=== modified file 'src/libconnman/Makefile.am'
192--- src/libconnman/Makefile.am 2011-01-12 22:17:00 +0000
193+++ src/libconnman/Makefile.am 2011-02-01 08:44:09 +0000
194@@ -14,4 +14,5 @@
195 libconnman_la_CPPFLAGS = \
196 $(GLIB_CFLAGS) \
197 $(GIO_CFLAGS) \
198- -I${top_builddir}/src/common
199+ -I${top_builddir}/src/common \
200+ -DG_LOG_DOMAIN=\"libconnman\"
201
202=== modified file 'src/libconnman/connman-manager.c'
203--- src/libconnman/connman-manager.c 2011-01-13 21:35:09 +0000
204+++ src/libconnman/connman-manager.c 2011-02-01 08:44:09 +0000
205@@ -146,6 +146,8 @@
206 g_dbus_proxy_call(priv->proxy, "ConnectService", parameters,
207 G_DBUS_CALL_FLAGS_NONE, CONNECT_TIMEOUT, cancellable,
208 connect_service_cb, simple);
209+
210+ /* FIXME: doesn't builder leak here? */
211 }
212
213 void connman_manager_connect_service_finish(ConnmanManager *self,
214
215=== modified file 'src/libconnman/connman-service.c'
216--- src/libconnman/connman-service.c 2011-01-13 22:20:43 +0000
217+++ src/libconnman/connman-service.c 2011-02-01 08:44:09 +0000
218@@ -45,9 +45,24 @@
219 gchar *error;
220 gchar *name;
221 ConnmanServiceType type;
222+ ConnmanServiceMode mode;
223 ConnmanServiceSecurity security;
224+ gboolean login_required;
225+ gchar *passphrase;
226+ gboolean passphrase_required;
227 guint8 strength;
228+ gboolean favorite;
229+ gboolean immutable;
230+ gboolean autoconnect;
231 gboolean setup_required;
232+ gchar *apn;
233+ gchar *mcc;
234+ gchar *mnc;
235+ gboolean roaming;
236+ gchar **nameservers;
237+ gchar **nameservers_configuration;
238+ gchar **domains;
239+ gchar **domains_configuration;
240 };
241
242 enum
243@@ -62,24 +77,24 @@
244 PROP_ERROR,
245 PROP_NAME,
246 PROP_TYPE,
247- /* PROP_MODE, */
248+ PROP_MODE,
249 PROP_SECURITY,
250- /* PROP_LOGIN_REQUIRED, */
251- /* PROP_PASSPHRASE, /\* rw *\/ */
252- /* PROP_PASSPHRASE_REQUIRED, */
253+ PROP_LOGIN_REQUIRED,
254+ PROP_PASSPHRASE, /* rw */
255+ PROP_PASSPHRASE_REQUIRED,
256 PROP_STRENGTH,
257- /* PROP_FAVORITE, */
258- /* PROP_IMMUTABLE, */
259- /* PROP_AUTOCONNECT, /\* rw *\/ */
260+ PROP_FAVORITE,
261+ PROP_IMMUTABLE,
262+ PROP_AUTOCONNECT, /* rw */
263 PROP_SETUP_REQUIRED,
264- /* PROP_APN, /\* rw *\/ */
265- /* PROP_MCC, */
266- /* PROP_MNC, */
267- /* PROP_ROAMING, */
268- /* PROP_NAMESERVERS, */
269- /* PROP_NAMESERVERS_CONFIGURATION, /\* rw *\/ */
270- /* PROP_DOMAINS, */
271- /* PROP_DOMAINS_CONFIGURATION, /\* rw *\/ */
272+ PROP_APN, /* rw */
273+ PROP_MCC,
274+ PROP_MNC,
275+ PROP_ROAMING,
276+ PROP_NAMESERVERS,
277+ PROP_NAMESERVERS_CONFIGURATION, /* rw */
278+ PROP_DOMAINS,
279+ PROP_DOMAINS_CONFIGURATION, /* rw */
280 /* PROP_IPV4, */
281 /* PROP_IPV4_CONFIGURATION, /\* rw *\/ */
282 /* PROP_IPV6, */
283@@ -92,6 +107,8 @@
284
285 #define SERVICE_NAME_UNKNOWN _("<unnamed>")
286 #define DISCONNECT_TIMEOUT 10000
287+#define MAX_NAMESERVERS 100
288+#define MAX_DOMAINS 100
289
290 struct service_state_string
291 {
292@@ -253,6 +270,7 @@
293 g_simple_async_result_propagate_error (simple, error);
294 }
295
296+/* property accessors */
297 ConnmanServiceState connman_service_get_state(ConnmanService *self)
298 {
299 ConnmanServicePrivate *priv = GET_PRIVATE(self);
300@@ -303,6 +321,47 @@
301 return priv->security;
302 }
303
304+gboolean connman_service_get_login_required(ConnmanService *self)
305+{
306+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
307+
308+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), FALSE);
309+ g_return_val_if_fail(priv != NULL, FALSE);
310+
311+ return priv->login_required;
312+}
313+
314+const gchar *connman_service_get_passphrase(ConnmanService *self)
315+{
316+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
317+
318+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
319+ g_return_val_if_fail(priv != NULL, NULL);
320+
321+ return priv->passphrase;
322+}
323+
324+void connman_service_set_passphrase(ConnmanService *self,
325+ const gchar *passphrase)
326+{
327+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
328+
329+ g_return_if_fail(CONNMAN_IS_SERVICE(self));
330+ g_return_if_fail(priv != NULL);
331+
332+ g_object_set(self, "passphrase", passphrase, NULL);
333+}
334+
335+gboolean connman_service_get_passphrase_required(ConnmanService *self)
336+{
337+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
338+
339+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), FALSE);
340+ g_return_val_if_fail(priv != NULL, FALSE);
341+
342+ return priv->passphrase_required;
343+}
344+
345 guint8 connman_service_get_strength(ConnmanService *self)
346 {
347 ConnmanServicePrivate *priv = GET_PRIVATE(self);
348@@ -313,7 +372,49 @@
349 return priv->strength;
350 }
351
352-gboolean connman_service_is_setup_required(ConnmanService *self)
353+gboolean connman_service_get_favorite(ConnmanService *self)
354+{
355+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
356+
357+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), FALSE);
358+ g_return_val_if_fail(priv != NULL, FALSE);
359+
360+ return priv->favorite;
361+}
362+
363+gboolean connman_service_get_immutable(ConnmanService *self)
364+{
365+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
366+
367+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), FALSE);
368+ g_return_val_if_fail(priv != NULL, FALSE);
369+
370+ return priv->immutable;
371+}
372+
373+gboolean connman_service_get_autoconnect(ConnmanService *self)
374+{
375+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
376+
377+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), FALSE);
378+ g_return_val_if_fail(priv != NULL, FALSE);
379+
380+ return priv->autoconnect;
381+}
382+
383+void connman_service_set_autoconnect(ConnmanService *self,
384+ gboolean autoconnect)
385+{
386+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
387+
388+ g_return_if_fail(CONNMAN_IS_SERVICE(self));
389+ g_return_if_fail(priv != NULL);
390+
391+ g_object_set(self, "autoconnect", autoconnect, NULL);
392+}
393+
394+
395+gboolean connman_service_get_setup_required(ConnmanService *self)
396 {
397 ConnmanServicePrivate *priv = GET_PRIVATE(self);
398
399@@ -323,6 +424,175 @@
400 return priv->setup_required;
401 }
402
403+const gchar *connman_service_get_apn(ConnmanService *self)
404+{
405+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
406+
407+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
408+ g_return_val_if_fail(priv != NULL, NULL);
409+
410+ return priv->apn;
411+}
412+
413+void connman_service_set_apn(ConnmanService *self, const gchar *apn)
414+{
415+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
416+
417+ g_return_if_fail(CONNMAN_IS_SERVICE(self));
418+ g_return_if_fail(priv != NULL);
419+
420+ g_object_set(self, "apn", apn, NULL);
421+}
422+
423+
424+const gchar *connman_service_get_mcc(ConnmanService *self)
425+{
426+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
427+
428+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
429+ g_return_val_if_fail(priv != NULL, NULL);
430+
431+ return priv->mcc;
432+}
433+
434+const gchar *connman_service_get_mnc(ConnmanService *self)
435+{
436+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
437+
438+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
439+ g_return_val_if_fail(priv != NULL, NULL);
440+
441+ return priv->mnc;
442+}
443+
444+gboolean connman_service_get_roaming(ConnmanService *self)
445+{
446+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
447+
448+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), FALSE);
449+ g_return_val_if_fail(priv != NULL, FALSE);
450+
451+ return priv->roaming;
452+}
453+
454+/**
455+ * connman_service_get_nameservers:
456+ *
457+ * @self:: self
458+ *
459+ * Returns: (array zero-terminated=1) (array length=false) (transfer none):
460+ * Null terminated list of strings, owned by ConnmanService. Caller must
461+ * copy if it uses them.
462+ */
463+gchar **connman_service_get_nameservers(ConnmanService *self)
464+{
465+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
466+
467+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
468+ g_return_val_if_fail(priv != NULL, NULL);
469+
470+ return priv->nameservers;
471+}
472+
473+/**
474+ * connman_service_get_nameservers_configuration:
475+ *
476+ * @self:: self
477+ *
478+ * Returns: (array zero-terminated=1) (array length=false) (transfer none):
479+ * Null terminated list of strings, owned by ConnmanService. Caller must
480+ * copy if it uses them.
481+ */
482+gchar **connman_service_get_nameservers_configuration(ConnmanService *self)
483+{
484+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
485+
486+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
487+ g_return_val_if_fail(priv != NULL, NULL);
488+
489+ return priv->nameservers_configuration;
490+}
491+
492+/**
493+ * connman_service_set_nameservers_configuration:
494+ *
495+ * @self:: self
496+ * @nameservers: (array zero-terminated=1) (transfer none): Null terminated list of strings, owned by caller.
497+ */
498+void connman_service_set_nameservers_configuration(ConnmanService *self,
499+ gchar **nameservers)
500+{
501+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
502+
503+ g_return_if_fail(CONNMAN_IS_SERVICE(self));
504+ g_return_if_fail(priv != NULL);
505+
506+ /* FIXME: figure out and _document_ how to clear the nameservers */
507+ if (nameservers == NULL)
508+ return;
509+
510+ g_object_set(self, "nameservers-configuration", nameservers, NULL);
511+}
512+
513+/**
514+ * connman_service_get_domains:
515+ *
516+ * @self:: self
517+ *
518+ * Returns: (array zero-terminated=1) (array length=false) (transfer none): Null terminated list of strings,
519+ * owned by ConnmanManager. Caller must copy if it uses them.
520+ */
521+gchar **connman_service_get_domains(ConnmanService *self)
522+{
523+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
524+
525+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
526+ g_return_val_if_fail(priv != NULL, NULL);
527+
528+ return priv->domains;
529+}
530+
531+/**
532+ * connman_service_get_domains_configuration:
533+ *
534+ * @self:: self
535+ *
536+ * Returns: (array zero-terminated=1) (array length=false) (transfer none):
537+ * Null terminated list of strings, owned by ConnmanService. Caller must
538+ * copy if it uses them.
539+ */
540+gchar **connman_service_get_domains_configuration(ConnmanService *self)
541+{
542+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
543+
544+ g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
545+ g_return_val_if_fail(priv != NULL, NULL);
546+
547+ return priv->domains_configuration;
548+}
549+
550+/**
551+ * connman_service_set_domains_configuration:
552+ *
553+ * @self:: self
554+ * @domains: (array zero-terminated=1) (transfer none): Null terminated list of strings, owned by caller.
555+ */
556+void connman_service_set_domains_configuration(ConnmanService *self,
557+ gchar **domains)
558+{
559+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
560+
561+ g_return_if_fail(CONNMAN_IS_SERVICE(self));
562+ g_return_if_fail(priv != NULL);
563+
564+ /* FIXME: figure out and _document_ how to clear the domains */
565+ if (domains == NULL)
566+ return;
567+
568+ g_object_set(self, "domains-configuration", domains, NULL);
569+}
570+
571+
572 const gchar *connman_service_get_path(ConnmanService *self)
573 {
574 ConnmanServicePrivate *priv = GET_PRIVATE(self);
575@@ -471,7 +741,7 @@
576 return "unknown";
577 }
578
579-static void update_state(ConnmanService *self, GVariant *variant)
580+static void state_updated(ConnmanService *self, GVariant *variant)
581 {
582 ConnmanServicePrivate *priv = GET_PRIVATE(self);
583 const gchar *s;
584@@ -484,7 +754,7 @@
585 g_variant_unref(variant);
586 }
587
588-static void update_error(ConnmanService *self, GVariant *variant)
589+static void error_updated(ConnmanService *self, GVariant *variant)
590 {
591 ConnmanServicePrivate *priv = GET_PRIVATE(self);
592
593@@ -496,7 +766,7 @@
594 g_variant_unref(variant);
595 }
596
597-static void update_name(ConnmanService *self, GVariant *variant)
598+static void name_updated(ConnmanService *self, GVariant *variant)
599 {
600 ConnmanServicePrivate *priv = GET_PRIVATE(self);
601
602@@ -508,7 +778,7 @@
603 g_variant_unref(variant);
604 }
605
606-static void update_type(ConnmanService *self, GVariant *variant)
607+static void type_updated(ConnmanService *self, GVariant *variant)
608 {
609 ConnmanServicePrivate *priv = GET_PRIVATE(self);
610 const gchar *s;
611@@ -521,7 +791,20 @@
612 g_variant_unref(variant);
613 }
614
615-static void update_security(ConnmanService *self, GVariant *variant)
616+static void mode_updated(ConnmanService *self, GVariant *variant)
617+{
618+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
619+ const gchar *s;
620+
621+ s = g_variant_get_string(variant, NULL);
622+ priv->security = connman_service_str2mode(s);
623+
624+ g_object_notify(G_OBJECT(self), "mode");
625+
626+ g_variant_unref(variant);
627+}
628+
629+static void security_updated(ConnmanService *self, GVariant *variant)
630 {
631 ConnmanServicePrivate *priv = GET_PRIVATE(self);
632 const gchar *s;
633@@ -534,7 +817,41 @@
634 g_variant_unref(variant);
635 }
636
637-static void update_strength(ConnmanService *self, GVariant *variant)
638+static void login_required_updated(ConnmanService *self, GVariant *variant)
639+{
640+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
641+
642+ priv->login_required = g_variant_get_boolean(variant);
643+
644+ g_object_notify(G_OBJECT(self), "login-required");
645+
646+ g_variant_unref(variant);
647+}
648+
649+static void passphrase_updated(ConnmanService *self, GVariant *variant)
650+{
651+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
652+
653+ g_free(priv->passphrase);
654+ priv->passphrase = g_variant_dup_string(variant, NULL);
655+
656+ g_object_notify(G_OBJECT(self), "passphrase");
657+
658+ g_variant_unref(variant);
659+}
660+
661+static void passphrase_required_updated(ConnmanService *self, GVariant *variant)
662+{
663+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
664+
665+ priv->passphrase_required = g_variant_get_boolean(variant);
666+
667+ g_object_notify(G_OBJECT(self), "passphrase-required");
668+
669+ g_variant_unref(variant);
670+}
671+
672+static void strength_updated(ConnmanService *self, GVariant *variant)
673 {
674 ConnmanServicePrivate *priv = GET_PRIVATE(self);
675
676@@ -545,7 +862,40 @@
677 g_variant_unref(variant);
678 }
679
680-static void update_setup_required(ConnmanService *self, GVariant *variant)
681+static void favorite_updated(ConnmanService *self, GVariant *variant)
682+{
683+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
684+
685+ priv->favorite = g_variant_get_boolean(variant);
686+
687+ g_object_notify(G_OBJECT(self), "favorite");
688+
689+ g_variant_unref(variant);
690+}
691+
692+static void immutable_updated(ConnmanService *self, GVariant *variant)
693+{
694+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
695+
696+ priv->immutable = g_variant_get_boolean(variant);
697+
698+ g_object_notify(G_OBJECT(self), "immutable");
699+
700+ g_variant_unref(variant);
701+}
702+
703+static void autoconnect_updated(ConnmanService *self, GVariant *variant)
704+{
705+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
706+
707+ priv->autoconnect = g_variant_get_boolean(variant);
708+
709+ g_object_notify(G_OBJECT(self), "autoconnect");
710+
711+ g_variant_unref(variant);
712+}
713+
714+static void setup_required_updated(ConnmanService *self, GVariant *variant)
715 {
716 ConnmanServicePrivate *priv = GET_PRIVATE(self);
717
718@@ -555,30 +905,143 @@
719 g_variant_unref(variant);
720 }
721
722-static void update_property(ConnmanService *self, const gchar *property,
723+static void apn_updated(ConnmanService *self, GVariant *variant)
724+{
725+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
726+
727+ g_free(priv->apn);
728+ priv->apn = g_variant_dup_string(variant, NULL);
729+
730+ g_object_notify(G_OBJECT(self), "apn");
731+
732+ g_variant_unref(variant);
733+}
734+
735+static void mcc_updated(ConnmanService *self, GVariant *variant)
736+{
737+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
738+
739+ g_free(priv->mcc);
740+ priv->mcc = g_variant_dup_string(variant, NULL);
741+
742+ g_object_notify(G_OBJECT(self), "mcc");
743+
744+ g_variant_unref(variant);
745+}
746+
747+static void mnc_updated(ConnmanService *self, GVariant *variant)
748+{
749+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
750+
751+ g_free(priv->mnc);
752+ priv->mnc = g_variant_dup_string(variant, NULL);
753+
754+ g_object_notify(G_OBJECT(self), "mnc");
755+
756+ g_variant_unref(variant);
757+}
758+
759+static void roaming_updated(ConnmanService *self, GVariant *variant)
760+{
761+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
762+
763+ priv->roaming = g_variant_get_boolean(variant);
764+
765+ g_object_notify(G_OBJECT(self), "roaming");
766+
767+ g_variant_unref(variant);
768+}
769+
770+static void nameservers_updated(ConnmanService *self, GVariant *variant)
771+{
772+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
773+
774+ g_strfreev(priv->nameservers);
775+ priv->nameservers = g_variant_dup_strv(variant, NULL);
776+
777+ g_object_notify(G_OBJECT(self), "nameservers");
778+}
779+
780+static void nameservers_configuration_updated(ConnmanService *self,
781+ GVariant *variant)
782+{
783+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
784+
785+ g_strfreev(priv->nameservers_configuration);
786+ priv->nameservers_configuration = g_variant_dup_strv(variant, NULL);
787+
788+ g_object_notify(G_OBJECT(self), "nameservers-configuration");
789+}
790+
791+static void domains_updated(ConnmanService *self, GVariant *variant)
792+{
793+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
794+
795+ g_strfreev(priv->domains);
796+ priv->domains = g_variant_dup_strv(variant, NULL);
797+
798+ g_object_notify(G_OBJECT(self), "domains");
799+}
800+
801+static void domains_configuration_updated(ConnmanService *self,
802+ GVariant *variant)
803+{
804+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
805+
806+ g_strfreev(priv->domains_configuration);
807+ priv->domains_configuration = g_variant_dup_strv(variant, NULL);
808+
809+ g_object_notify(G_OBJECT(self), "domains-configuration");
810+}
811+
812+struct property_map
813+{
814+ const gchar *property;
815+ void (*handler)(ConnmanService *self, GVariant *variant);
816+};
817+
818+struct property_map property_table[] = {
819+ { CONNMAN_PROPERTY_STATE, state_updated },
820+ { CONNMAN_PROPERTY_ERROR, error_updated },
821+ { CONNMAN_PROPERTY_NAME, name_updated },
822+ { CONNMAN_PROPERTY_TYPE, type_updated },
823+ { CONNMAN_PROPERTY_MODE, mode_updated },
824+ { CONNMAN_PROPERTY_SECURITY, security_updated },
825+ { CONNMAN_PROPERTY_LOGIN_REQUIRED, login_required_updated },
826+ { CONNMAN_PROPERTY_PASSPHRASE, passphrase_updated },
827+ { CONNMAN_PROPERTY_PASSPHRASE_REQUIRED, passphrase_required_updated },
828+ { CONNMAN_PROPERTY_STRENGTH, strength_updated },
829+ { CONNMAN_PROPERTY_FAVORITE, favorite_updated },
830+ { CONNMAN_PROPERTY_IMMUTABLE, immutable_updated },
831+ { CONNMAN_PROPERTY_AUTOCONNECT, autoconnect_updated },
832+ { CONNMAN_PROPERTY_SETUP_REQUIRED, setup_required_updated },
833+ { CONNMAN_PROPERTY_APN, apn_updated },
834+ { CONNMAN_PROPERTY_MCC, mcc_updated },
835+ { CONNMAN_PROPERTY_MNC, mnc_updated },
836+ { CONNMAN_PROPERTY_ROAMING, roaming_updated },
837+ { CONNMAN_PROPERTY_NAMESERVERS, nameservers_updated },
838+ { CONNMAN_PROPERTY_NAMESERVERS_CONFIGURATION, nameservers_configuration_updated },
839+ { CONNMAN_PROPERTY_DOMAINS, domains_updated },
840+ { CONNMAN_PROPERTY_DOMAINS_CONFIGURATION, domains_configuration_updated },
841+};
842+
843+static void property_updated(ConnmanService *self, const gchar *property,
844 GVariant *variant)
845 {
846- if (g_strcmp0(property, CONNMAN_PROPERTY_STATE) == 0) {
847- update_state(self, variant);
848- } else if (g_strcmp0(property, CONNMAN_PROPERTY_ERROR) == 0) {
849- update_error(self, variant);
850- } else if (g_strcmp0(property, CONNMAN_PROPERTY_NAME) == 0) {
851- update_name(self, variant);
852- } else if (g_strcmp0(property, CONNMAN_PROPERTY_TYPE) == 0) {
853- update_type(self, variant);
854- } else if (g_strcmp0(property, CONNMAN_PROPERTY_SECURITY) == 0) {
855- update_security(self, variant);
856- } else if (g_strcmp0(property, CONNMAN_PROPERTY_STRENGTH) == 0) {
857- update_strength(self, variant);
858- } else if (g_strcmp0(property, CONNMAN_PROPERTY_SETUP_REQUIRED) == 0) {
859- update_setup_required(self, variant);
860- } else {
861- /* unknown property */
862- g_variant_unref(variant);
863+ guint i;
864+
865+ for (i = 0; i < G_N_ELEMENTS(property_table); i++) {
866+ struct property_map *p = &property_table[i];
867+
868+ if (g_strcmp0(property, p->property) == 0) {
869+ p->handler(self, variant);
870+ /* callee owns the variant now */
871+ return;
872+ }
873 }
874
875- /* callee owns the variant now */
876- variant = NULL;
877+ /* unknown property */
878+ g_variant_unref(variant);
879 }
880
881 static void property_changed(ConnmanService *self, GVariant *parameters)
882@@ -592,7 +1055,7 @@
883 g_variant_get(parameters, "(sv)", &name, &variant);
884
885 /* callee takes the ownership of the variant */
886- update_property(self, name, variant);
887+ property_updated(self, name, variant);
888
889 g_free(name);
890 }
891@@ -651,7 +1114,7 @@
892
893 while (g_variant_iter_next(&dict_iter, "{sv}", &name, &variant)) {
894 /* callee owns the variant now */
895- update_property(self, name, variant);
896+ property_updated(self, name, variant);
897
898 g_free(name);
899 }
900@@ -718,6 +1181,133 @@
901 get_properties(self);
902 }
903
904+static void set_service_property_cb(GObject *object, GAsyncResult *res,
905+ gpointer user_data)
906+{
907+ ConnmanService *self = CONNMAN_SERVICE(user_data);
908+ GDBusProxy *proxy = G_DBUS_PROXY(object);
909+ GError *error = NULL;
910+
911+ g_dbus_proxy_call_finish(proxy, res, &error);
912+
913+ if (error != NULL) {
914+ g_warning("ConnmanService SetProperty() failed: %s", error->message);
915+ g_error_free(error);
916+ }
917+
918+ /* trick to avoid destroying self during async call */
919+ g_object_unref(self);
920+}
921+
922+static void set_service_property(ConnmanService *self, const gchar *property,
923+ GVariant *value)
924+{
925+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
926+ GVariant *parameters;
927+
928+ g_return_if_fail(CONNMAN_IS_SERVICE(self));
929+ g_return_if_fail(priv != NULL);
930+
931+ parameters = g_variant_new("(sv)", property, value);
932+
933+ g_dbus_proxy_call(priv->proxy, "SetProperty", parameters,
934+ G_DBUS_CALL_FLAGS_NONE, -1, NULL,
935+ set_service_property_cb, g_object_ref(self));
936+}
937+
938+static void update_passphrase(ConnmanService *self)
939+{
940+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
941+ GVariant *value;
942+
943+ if (priv->passphrase == NULL)
944+ return;
945+
946+ value = g_variant_new("(s)", priv->passphrase);
947+
948+ set_service_property(self, "Passphrase", value);
949+}
950+
951+static void update_autoconnect(ConnmanService *self)
952+{
953+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
954+ GVariant *value;
955+
956+ if (priv->apn == NULL)
957+ return;
958+
959+ value = g_variant_new("(b)", priv->autoconnect);
960+
961+ set_service_property(self, "AutoConnect", value);
962+}
963+
964+static void update_apn(ConnmanService *self)
965+{
966+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
967+ GVariant *value;
968+
969+ if (priv->apn == NULL)
970+ return;
971+
972+ value = g_variant_new("(s)", priv->apn);
973+
974+ set_service_property(self, "APN", value);
975+}
976+
977+static void update_nameservers_configuration(ConnmanService *self)
978+{
979+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
980+ GVariantBuilder builder;
981+ GVariant *value;
982+ guint len, i;
983+ gchar **p;
984+
985+ if (priv->nameservers_configuration == NULL)
986+ /* FIXME: how to clear the nameservers? */
987+ return;
988+
989+ len = g_strv_length(priv->nameservers_configuration);
990+ p = priv->nameservers_configuration;
991+
992+ g_variant_builder_init(&builder, G_VARIANT_TYPE("as"));
993+
994+ for (i = 0; i < len; i++) {
995+ g_variant_builder_add(&builder, "s", *p);
996+ p++;
997+ }
998+
999+ value = g_variant_new("as", &builder);
1000+
1001+ set_service_property(self, "Nameservers.Configuration", value);
1002+}
1003+
1004+static void update_domains_configuration(ConnmanService *self)
1005+{
1006+ ConnmanServicePrivate *priv = GET_PRIVATE(self);
1007+ GVariantBuilder builder;
1008+ GVariant *value;
1009+ guint len, i;
1010+ gchar **p;
1011+
1012+ if (priv->domains_configuration == NULL)
1013+ /* FIXME: how to clear the domains? */
1014+ return;
1015+
1016+ len = g_strv_length(priv->domains_configuration);
1017+ p = priv->domains_configuration;
1018+
1019+ g_variant_builder_init(&builder, G_VARIANT_TYPE("as"));
1020+
1021+ for (i = 0; i < len; i++) {
1022+ g_variant_builder_add(&builder, "s", *p);
1023+ p++;
1024+ }
1025+
1026+ value = g_variant_new("as", &builder);
1027+
1028+ set_service_property(self, "Domains.Configuration", value);
1029+}
1030+
1031 static void connman_service_set_property(GObject *object,
1032 guint property_id,
1033 const GValue *value,
1034@@ -750,15 +1340,69 @@
1035 case PROP_TYPE:
1036 priv->type = g_value_get_uint(value);
1037 break;
1038+ case PROP_MODE:
1039+ priv->mode = g_value_get_uint(value);
1040+ break;
1041 case PROP_SECURITY:
1042 priv->security = g_value_get_uint(value);
1043 break;
1044+ case PROP_LOGIN_REQUIRED:
1045+ priv->login_required = g_value_get_boolean(value);
1046+ break;
1047+ case PROP_PASSPHRASE:
1048+ priv->passphrase = g_value_dup_string(value);
1049+ update_passphrase(self);
1050+ break;
1051+ case PROP_PASSPHRASE_REQUIRED:
1052+ priv->passphrase_required = g_value_get_boolean(value);
1053+ break;
1054 case PROP_STRENGTH:
1055 priv->strength = g_value_get_uchar(value);
1056 break;
1057+ case PROP_FAVORITE:
1058+ priv->favorite = g_value_get_boolean(value);
1059+ break;
1060+ case PROP_IMMUTABLE:
1061+ priv->immutable = g_value_get_boolean(value);
1062+ break;
1063+ case PROP_AUTOCONNECT:
1064+ priv->autoconnect = g_value_get_boolean(value);
1065+ update_autoconnect(self);
1066+ break;
1067 case PROP_SETUP_REQUIRED:
1068 priv->setup_required = g_value_get_boolean(value);
1069 break;
1070+ case PROP_APN:
1071+ priv->apn = g_value_dup_string(value);
1072+ update_apn(self);
1073+ break;
1074+ case PROP_MCC:
1075+ priv->mcc = g_value_dup_string(value);
1076+ break;
1077+ case PROP_MNC:
1078+ priv->mnc = g_value_dup_string(value);
1079+ break;
1080+ case PROP_ROAMING:
1081+ priv->roaming = g_value_get_boolean(value);
1082+ break;
1083+ case PROP_NAMESERVERS:
1084+ g_strfreev(priv->nameservers);
1085+ priv->nameservers = g_value_get_boxed(value);
1086+ break;
1087+ case PROP_NAMESERVERS_CONFIGURATION:
1088+ g_strfreev(priv->nameservers_configuration);
1089+ priv->nameservers_configuration = g_strdupv(g_value_get_boxed(value));
1090+ update_nameservers_configuration(self);
1091+ break;
1092+ case PROP_DOMAINS:
1093+ g_strfreev(priv->domains);
1094+ priv->domains = g_value_get_boxed(value);
1095+ break;
1096+ case PROP_DOMAINS_CONFIGURATION:
1097+ g_strfreev(priv->domains_configuration);
1098+ priv->domains_configuration = g_strdupv(g_value_get_boxed(value));
1099+ update_domains_configuration(self);
1100+ break;
1101 default:
1102 /* We don't have any other property... */
1103 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
1104@@ -793,15 +1437,60 @@
1105 case PROP_TYPE:
1106 g_value_set_uint(value, priv->type);
1107 break;
1108+ case PROP_MODE:
1109+ g_value_set_boolean(value, priv->mode);
1110+ break;
1111 case PROP_SECURITY:
1112 g_value_set_uint(value, priv->security);
1113 break;
1114+ case PROP_LOGIN_REQUIRED:
1115+ g_value_set_boolean(value, priv->login_required);
1116+ break;
1117+ case PROP_PASSPHRASE:
1118+ g_value_set_string(value, priv->passphrase);
1119+ break;
1120+ case PROP_PASSPHRASE_REQUIRED:
1121+ g_value_set_boolean(value, priv->passphrase_required);
1122+ break;
1123 case PROP_STRENGTH:
1124 g_value_set_uchar(value, priv->strength);
1125 break;
1126+ case PROP_FAVORITE:
1127+ g_value_set_boolean(value, priv->favorite);
1128+ break;
1129+ case PROP_IMMUTABLE:
1130+ g_value_set_boolean(value, priv->immutable);
1131+ break;
1132+ case PROP_AUTOCONNECT:
1133+ g_value_set_boolean(value, priv->autoconnect);
1134+ break;
1135 case PROP_SETUP_REQUIRED:
1136 g_value_set_boolean(value, priv->setup_required);
1137 break;
1138+ case PROP_APN:
1139+ g_value_set_string(value, priv->apn);
1140+ break;
1141+ case PROP_MCC:
1142+ g_value_set_string(value, priv->mcc);
1143+ break;
1144+ case PROP_MNC:
1145+ g_value_set_string(value, priv->mnc);
1146+ break;
1147+ case PROP_ROAMING:
1148+ g_value_set_boolean(value, priv->roaming);
1149+ break;
1150+ case PROP_NAMESERVERS:
1151+ g_value_set_boxed(value, priv->nameservers);
1152+ break;
1153+ case PROP_NAMESERVERS_CONFIGURATION:
1154+ g_value_set_boxed(value, priv->nameservers_configuration);
1155+ break;
1156+ case PROP_DOMAINS:
1157+ g_value_set_boxed(value, priv->domains);
1158+ break;
1159+ case PROP_DOMAINS_CONFIGURATION:
1160+ g_value_set_boxed(value, priv->domains_configuration);
1161+ break;
1162 default:
1163 /* We don't have any other property... */
1164 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
1165@@ -898,6 +1587,14 @@
1166 G_PARAM_READABLE);
1167 g_object_class_install_property(gobject_class, PROP_TYPE, pspec);
1168
1169+ pspec = g_param_spec_uint("mode",
1170+ "ConnmanService's mode property",
1171+ "Mode of the service",
1172+ 0, G_MAXUINT,
1173+ CONNMAN_SERVICE_MODE_MANAGED,
1174+ G_PARAM_READABLE);
1175+ g_object_class_install_property(gobject_class, PROP_MODE, pspec);
1176+
1177 pspec = g_param_spec_uint("security",
1178 "ConnmanService's security property",
1179 "Security type of the service",
1180@@ -906,6 +1603,28 @@
1181 G_PARAM_READABLE);
1182 g_object_class_install_property(gobject_class, PROP_SECURITY, pspec);
1183
1184+ pspec = g_param_spec_boolean("login-required",
1185+ "ConnmanService's login-required property",
1186+ "Does network require separate login",
1187+ FALSE,
1188+ G_PARAM_READABLE);
1189+ g_object_class_install_property(gobject_class, PROP_LOGIN_REQUIRED, pspec);
1190+
1191+ pspec = g_param_spec_string("passphrase",
1192+ "ConnmanService's passphrase",
1193+ "Set passphrase for the service",
1194+ NULL,
1195+ G_PARAM_READWRITE);
1196+ g_object_class_install_property(gobject_class, PROP_PASSPHRASE, pspec);
1197+
1198+ pspec = g_param_spec_boolean("passphrase-required",
1199+ "ConnmanService's passphrase-required property",
1200+ "Does network require passphrase",
1201+ FALSE,
1202+ G_PARAM_READABLE);
1203+ g_object_class_install_property(gobject_class, PROP_PASSPHRASE_REQUIRED,
1204+ pspec);
1205+
1206 pspec = g_param_spec_uint("strength",
1207 "ConnmanService's strength property",
1208 "Current signal strength of the service",
1209@@ -914,12 +1633,96 @@
1210 G_PARAM_READABLE);
1211 g_object_class_install_property(gobject_class, PROP_SECURITY, pspec);
1212
1213+ pspec = g_param_spec_boolean("favorite",
1214+ "ConnmanService's favorite property",
1215+ "Is this service saved",
1216+ FALSE,
1217+ G_PARAM_READABLE);
1218+ g_object_class_install_property(gobject_class, PROP_FAVORITE, pspec);
1219+
1220+ pspec = g_param_spec_boolean("immutable",
1221+ "ConnmanService's immutable property",
1222+ "Is this service immutable",
1223+ FALSE,
1224+ G_PARAM_READABLE);
1225+ g_object_class_install_property(gobject_class, PROP_IMMUTABLE,
1226+ pspec);
1227+
1228+ pspec = g_param_spec_boolean("autoconnect",
1229+ "ConnmanService's autoconnect property",
1230+ "Can service connect automatically",
1231+ FALSE,
1232+ G_PARAM_READWRITE);
1233+ g_object_class_install_property(gobject_class, PROP_AUTOCONNECT, pspec);
1234+
1235 pspec = g_param_spec_boolean("setup-required",
1236 "ConnmanService's setup-required property",
1237 "Is user configuration needed, eg APN",
1238 FALSE,
1239 G_PARAM_READABLE);
1240 g_object_class_install_property(gobject_class, PROP_SETUP_REQUIRED, pspec);
1241+
1242+ pspec = g_param_spec_string("apn",
1243+ "ConnmanService's APN",
1244+ "Set APN for the service",
1245+ NULL,
1246+ G_PARAM_READWRITE);
1247+ g_object_class_install_property(gobject_class, PROP_APN, pspec);
1248+
1249+ pspec = g_param_spec_string("mcc",
1250+ "ConnmanService's Mobile Country Code",
1251+ "Set MCC for the service",
1252+ NULL,
1253+ G_PARAM_READABLE);
1254+ g_object_class_install_property(gobject_class, PROP_MCC, pspec);
1255+
1256+ pspec = g_param_spec_string("mnc",
1257+ "ConnmanService's Mobile Network Code",
1258+ "Set MNC for the service",
1259+ NULL,
1260+ G_PARAM_READABLE);
1261+ g_object_class_install_property(gobject_class, PROP_MNC, pspec);
1262+
1263+ pspec = g_param_spec_boolean("roaming",
1264+ "ConnmanService's roaming property",
1265+ "Is the service on a foreign network",
1266+ FALSE,
1267+ G_PARAM_READABLE);
1268+ g_object_class_install_property(gobject_class, PROP_ROAMING, pspec);
1269+
1270+ pspec = g_param_spec_boxed("nameservers",
1271+ "ConnmanService's nameservers property",
1272+ "Null terminated list of nameserver strings "
1273+ "in priority order",
1274+ G_TYPE_STRV,
1275+ G_PARAM_READABLE);
1276+ g_object_class_install_property(gobject_class, PROP_NAMESERVERS, pspec);
1277+
1278+ pspec = g_param_spec_boxed("nameservers-configuration",
1279+ "ConnmanService's nameservers-configuration property",
1280+ "Null terminated list of nameserver strings set by the user, "
1281+ "in priority order",
1282+ G_TYPE_STRV,
1283+ G_PARAM_READWRITE);
1284+ g_object_class_install_property(gobject_class, PROP_NAMESERVERS_CONFIGURATION,
1285+ pspec);
1286+
1287+ pspec = g_param_spec_boxed("domains",
1288+ "ConnmanService's domains property",
1289+ "Null terminated list of strings of domains currently in use "
1290+ "in priority order",
1291+ G_TYPE_STRV,
1292+ G_PARAM_READABLE);
1293+ g_object_class_install_property(gobject_class, PROP_DOMAINS, pspec);
1294+
1295+ pspec = g_param_spec_boxed("domains-configuration",
1296+ "ConnmanService's domains-configuration property",
1297+ "Null terminated list of string of domains set by the user, "
1298+ "in priority order",
1299+ G_TYPE_STRV,
1300+ G_PARAM_READWRITE);
1301+ g_object_class_install_property(gobject_class, PROP_DOMAINS_CONFIGURATION,
1302+ pspec);
1303 }
1304
1305 static void connman_service_init(ConnmanService *self)
1306
1307=== modified file 'src/libconnman/connman-service.h'
1308--- src/libconnman/connman-service.h 2010-12-01 07:47:53 +0000
1309+++ src/libconnman/connman-service.h 2011-02-01 08:44:09 +0000
1310@@ -88,14 +88,39 @@
1311
1312 GType connman_service_get_type(void);
1313
1314+/* property accessors */
1315 ConnmanServiceState connman_service_get_state(ConnmanService *self);
1316 const gchar *connman_service_get_error(ConnmanService *self);
1317 const gchar *connman_service_get_name(ConnmanService *self);
1318 ConnmanServiceType connman_service_get_service_type(ConnmanService *self);
1319 ConnmanServiceSecurity connman_service_get_security(ConnmanService *self);
1320+gboolean connman_service_get_login_required(ConnmanService *self);
1321+const gchar *connman_service_get_passphrase(ConnmanService *self);
1322+void connman_service_set_passphrase(ConnmanService *self,
1323+ const gchar *passphrase);
1324+gboolean connman_service_get_passphrase_required(ConnmanService *self);
1325 guint8 connman_service_get_strength(ConnmanService *self);
1326-gboolean connman_service_is_setup_required(ConnmanService *self);
1327+gboolean connman_service_get_favorite(ConnmanService *self);
1328+gboolean connman_service_get_immutable(ConnmanService *self);
1329+gboolean connman_service_get_autoconnect(ConnmanService *self);
1330+void connman_service_set_autoconnect(ConnmanService *self,
1331+ gboolean autoconnect);
1332+gboolean connman_service_get_setup_required(ConnmanService *self);
1333+const gchar *connman_service_get_apn(ConnmanService *self);
1334+void connman_service_set_apn(ConnmanService *self, const gchar *apn);
1335+const gchar *connman_service_get_mcc(ConnmanService *self);
1336+const gchar *connman_service_get_mnc(ConnmanService *self);
1337+gboolean connman_service_get_roaming(ConnmanService *self);
1338+gchar **connman_service_get_nameservers(ConnmanService *self);
1339+gchar **connman_service_get_nameservers_configuration(ConnmanService *self);
1340+void connman_service_set_nameservers_configuration(ConnmanService *self,
1341+ gchar **nameservers);
1342+gchar **connman_service_get_domains(ConnmanService *self);
1343+gchar **connman_service_get_domains_configuration(ConnmanService *self);
1344+void connman_service_set_domains_configuration(ConnmanService *self,
1345+ gchar **domains);
1346
1347+/* methods */
1348 void connman_service_connect(ConnmanService *self,
1349 GAsyncReadyCallback callback,
1350 gpointer user_data);
1351
1352=== modified file 'src/libconnman/connman.h'
1353--- src/libconnman/connman.h 2010-12-01 07:47:53 +0000
1354+++ src/libconnman/connman.h 2011-02-01 08:44:09 +0000
1355@@ -58,6 +58,20 @@
1356 #define CONNMAN_PROPERTY_SETUP_REQUIRED "SetupRequired"
1357 #define CONNMAN_PROPERTY_SECURITY "Security"
1358 #define CONNMAN_PROPERTY_ERROR "Error"
1359+#define CONNMAN_PROPERTY_MODE "Mode"
1360+#define CONNMAN_PROPERTY_LOGIN_REQUIRED "LoginRequired"
1361+#define CONNMAN_PROPERTY_PASSPHRASE_REQUIRED "PassphraseRequired"
1362+#define CONNMAN_PROPERTY_FAVORITE "Favorite"
1363+#define CONNMAN_PROPERTY_IMMUTABLE "Immutable"
1364+#define CONNMAN_PROPERTY_AUTOCONNECT "AutoConnect"
1365+#define CONNMAN_PROPERTY_APN "APN"
1366+#define CONNMAN_PROPERTY_MCC "MCC"
1367+#define CONNMAN_PROPERTY_MNC "MNC"
1368+#define CONNMAN_PROPERTY_ROAMING "Roaming"
1369+#define CONNMAN_PROPERTY_NAMESERVERS "Nameservers"
1370+#define CONNMAN_PROPERTY_NAMESERVERS_CONFIGURATION "Nameservers.Configuration"
1371+#define CONNMAN_PROPERTY_DOMAINS "Domains"
1372+#define CONNMAN_PROPERTY_DOMAINS_CONFIGURATION "Domains.Configuration"
1373
1374 #define CONNMAN_STATE_ONLINE "online"
1375 #define CONNMAN_STATE_CONNECTING "connecting"
1376
1377=== modified file 'tests/libconnman-tool.c'
1378--- tests/libconnman-tool.c 2011-01-12 22:53:21 +0000
1379+++ tests/libconnman-tool.c 2011-02-01 08:44:09 +0000
1380@@ -143,7 +143,7 @@
1381 gpointer user_data)
1382 {
1383 g_print("service %s setup-required %d\n", connman_service_get_path(service),
1384- connman_service_is_setup_required(service));
1385+ connman_service_get_setup_required(service));
1386 }
1387
1388 static void new_service(ConnmanService *service)
1389@@ -155,7 +155,7 @@
1390 g_print(" type %d\n", connman_service_get_service_type(service));
1391 g_print(" security %d\n", connman_service_get_security(service));
1392 g_print(" strength %d\n", connman_service_get_strength(service));
1393- g_print(" setup_required %d\n", connman_service_is_setup_required(service));
1394+ g_print(" setup_required %d\n", connman_service_get_setup_required(service));
1395
1396 g_signal_connect(service, "notify::state", G_CALLBACK(state_updated),
1397 NULL);
1398
1399=== modified file 'tests/libconnman-vala/libconnman-vala.vala'
1400--- tests/libconnman-vala/libconnman-vala.vala 2011-01-25 10:11:52 +0000
1401+++ tests/libconnman-vala/libconnman-vala.vala 2011-02-01 08:44:09 +0000
1402@@ -18,6 +18,8 @@
1403 * with this program. If not, see <http://www.gnu.org/licenses/>.
1404 */
1405
1406+using Connman;
1407+
1408 static Connman.Manager manager;
1409 static MainLoop loop;
1410
1411@@ -72,17 +74,130 @@
1412 return;
1413 }
1414
1415+ /* service.type will call service_get_type() which is not what we want */
1416+ var type = service.get_service_type();
1417+
1418 stdout.printf("[ %s ]\n", service.path);
1419 stdout.printf(" Name = %s\n", service.name);
1420-
1421- /* service.type will call service_get_type() which is not what we want */
1422- stdout.printf(" Type = %u\n", service.get_service_type());
1423-
1424- stdout.printf(" Security = %u\n", service.security);
1425 stdout.printf(" State = %u\n", service.state);
1426- stdout.printf(" Strength = %u\n", service.strength);
1427- stdout.printf(" SetupRequired = %s\n",
1428- service.is_setup_required() ? "true" : "false");
1429+
1430+ if (type == ServiceType.ETHERNET) {
1431+ stdout.printf(" Type = Ethernet\n");
1432+ } else if (type == ServiceType.WIFI) {
1433+ stdout.printf(" Type = Wifi\n");
1434+ stdout.printf(" Security = %u\n", service.security);
1435+ stdout.printf(" Strength = %u\n", service.strength);
1436+ stdout.printf(" Passphrase = %s\n", service.passphrase);
1437+ stdout.printf(" PassphraseRequired = %s\n",
1438+ service.passphrase_required ? "true" : "false");
1439+ } else if (type == ServiceType.CELLULAR) {
1440+ stdout.printf(" Type = Cellular\n");
1441+ stdout.printf(" SetupRequired = %s\n",
1442+ service.setup_required ? "true" : "false");
1443+ stdout.printf(" APN = %s\n", service.apn);
1444+ stdout.printf(" MCC = %s\n", service.mcc);
1445+ stdout.printf(" MNC = %s\n", service.mnc);
1446+ }
1447+
1448+ stdout.printf(" Nameservers = %s\n",
1449+ string.joinv(" ", service.get_nameservers()));
1450+ stdout.printf(" Nameservers.Configuration = %s\n",
1451+ string.joinv(" ", service.get_nameservers_configuration()));
1452+ stdout.printf(" Domains = %s\n",
1453+ string.joinv(" ", service.get_domains()));
1454+ stdout.printf(" Domains.Configuration = %s\n",
1455+ string.joinv(" ", service.get_domains_configuration()));
1456+
1457+ stdout.printf(" Error = %s\n", service.error);
1458+ stdout.printf(" AutoConnect = %s\n",
1459+ service.autoconnect ? "true" : "false");
1460+ stdout.printf(" Favorite = %s\n",
1461+ service.favorite ? "true" : "false");
1462+ stdout.printf(" Immutable = %s\n",
1463+ service.immutable ? "true" : "false");
1464+}
1465+
1466+static void edit_passphrase(Service service, string[] args) {
1467+
1468+ if (args.length != 1) {
1469+ stdout.printf("Invalid number of arguments: %d\n", args.length);
1470+ return;
1471+ }
1472+
1473+ var passphrase = args[0];
1474+ service.passphrase = passphrase;
1475+}
1476+
1477+static void edit_nameservers(Service service, string[] args) {
1478+
1479+ string[] nameservers;
1480+
1481+ if (args.length < 1) {
1482+ stdout.printf("Invalid number of arguments: %d\n", args.length);
1483+ return;
1484+ }
1485+
1486+ if (args[0] != "auto")
1487+ nameservers = args;
1488+ else
1489+ nameservers = {};
1490+
1491+ service.set_nameservers_configuration(nameservers);
1492+}
1493+
1494+static void edit_domains(Service service, string[] args) {
1495+
1496+ string[] domains;
1497+
1498+ if (args.length < 1) {
1499+ stdout.printf("Invalid number of arguments: %d\n", args.length);
1500+ return;
1501+ }
1502+
1503+ if (args[0] != "auto")
1504+ domains = args;
1505+ else
1506+ domains = {};
1507+
1508+ service.set_domains_configuration(domains);
1509+}
1510+
1511+static void edit(string[] args) {
1512+
1513+ if (args.length < 2) {
1514+ stdout.printf("Invalid number of arguments: %d\n", args.length);
1515+ return;
1516+ }
1517+
1518+ var path = args[0];
1519+ var property = args[1];
1520+ string[] edit_args = {};
1521+
1522+ if (args.length == 3) {
1523+ edit_args += args[2];
1524+ }
1525+ else if (args.length > 3) {
1526+ edit_args = args[2: args.length - 1];
1527+ }
1528+
1529+ var service = manager.get_service(path);
1530+
1531+ if (service == null) {
1532+ stdout.printf("service %s not found", path);
1533+ return;
1534+ }
1535+
1536+ switch(property) {
1537+ case "passphrase":
1538+ edit_passphrase(service, edit_args);
1539+ break;
1540+ case "nameservers":
1541+ edit_nameservers(service, edit_args);
1542+ break;
1543+ case "domains":
1544+ edit_domains(service, edit_args);
1545+ break;
1546+ }
1547 }
1548
1549 static bool cmd_handler() {
1550@@ -95,11 +210,12 @@
1551 args += tokens[1];
1552 }
1553 if (tokens.length > 2) {
1554- args = tokens[1:-1];
1555+ args = tokens[1:tokens.length];
1556 }
1557
1558 switch (cmd) {
1559 case "quit":
1560+ case "q":
1561 quit();
1562 break;
1563 case "list":
1564@@ -114,6 +230,9 @@
1565 case "show":
1566 show(args);
1567 break;
1568+ case "edit":
1569+ edit(args);
1570+ break;
1571 default:
1572 stdout.printf("Unknown command: %s\n", cmd);
1573 break;
1574
1575=== modified file 'tests/mock-connman-service.c'
1576--- tests/mock-connman-service.c 2010-11-24 13:00:30 +0000
1577+++ tests/mock-connman-service.c 2011-02-01 08:44:09 +0000
1578@@ -189,7 +189,7 @@
1579 return priv->strength;
1580 }
1581
1582-gboolean connman_service_is_setup_required(ConnmanService *self)
1583+gboolean connman_service_get_setup_required(ConnmanService *self)
1584 {
1585 ConnmanServicePrivate *priv = GET_PRIVATE(self);
1586

Subscribers

People subscribed via source and target branches