e_dbus/connman: add readonly Proxy properties
[framework/uifw/edbus.git] / src / lib / connman / e_connman_service.c
1 #include "e_connman_private.h"
2
3 E_Connman_Element *
4 e_connman_service_get(const char *path)
5 {
6    E_Connman_Element *service;
7
8    EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
9
10    service = e_connman_element_get(path);
11    if (!service)
12       return NULL;
13
14    if (!e_connman_element_is_service(service))
15      {
16         WRN("path '%s' is not a service!", path);
17         return NULL;
18      }
19
20    return service;
21 }
22
23 /**
24  * Connect this service.
25  *
26  * Connect this service. It will attempt to connect
27  * WiFi, WiMAX or Bluetooth services.
28  *
29  * For Ethernet devices this method can only be used
30  * if it has previously been disconnected. Otherwise
31  * the plugging of a cable will trigger connecting
32  * automatically. If no cable is plugged in this method
33  * will fail.
34  *
35  * @param service path to call method on server.
36  * @param cb function to call when server replies or some error happens.
37  * @param data data to give to cb when it is called.
38  *
39  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
40  */
41 Eina_Bool
42 e_connman_service_connect(E_Connman_Element *service, E_DBus_Method_Return_Cb cb, const void *data)
43 {
44    const char name[] = "Connect";
45
46    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
47    return e_connman_element_call_full
48              (service, name, NULL, &service->_pending.service_connect, cb, data);
49 }
50
51 /**
52  * Disconnect this service.
53  *
54  * Disconnect this service. If the service is not
55  * connected an error message will be generated.
56  *
57  * On Ethernet devices this will disconnect the IP
58  * details from the service. It will not magically
59  * unplug the cable. When no cable is plugged in this
60  * method will fail.
61  *
62  * This method can also be used to abort a previous
63  * connectiong attempt via the Connect method.
64  *
65  * @param service path to call method on server.
66  * @param cb function to call when server replies or some error happens.
67  * @param data data to give to cb when it is called.
68  *
69  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
70  */
71 Eina_Bool
72 e_connman_service_disconnect(E_Connman_Element *service, E_DBus_Method_Return_Cb cb, const void *data)
73 {
74    const char name[] = "Disconnect";
75
76    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
77    return e_connman_element_call_full
78              (service, name, NULL, &service->_pending.service_disconnect, cb, data);
79 }
80
81 /**
82  * Remove this service.
83  *
84  * A successfully connected service with Favorite=true
85  * can be removed this way. If it is connected, it will
86  * be automatically disconnected first.
87  *
88  * If the service requires a passphrase it will be
89  * cleared and forgotten when removing.
90  *
91  * This is similar to setting the Favorite property
92  * to false, but that is currently not supported.
93  *
94  * In the case a connection attempt failed and the
95  * service is in the State=failure, this method can
96  * also be used to reset the service.
97  *
98  * Calling this method on Ethernet devices will cause
99  * an error message. It is not possible to remove these
100  * kind of devices.
101  *
102  * @param service path to call method on server.
103  * @param cb function to call when server replies or some error happens.
104  * @param data data to give to cb when it is called.
105  *
106  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
107  */
108 Eina_Bool
109 e_connman_service_remove(E_Connman_Element *service, E_DBus_Method_Return_Cb cb, const void *data)
110 {
111    const char name[] = "Remove";
112
113    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
114    return e_connman_element_call_full
115              (service, name, NULL, &service->_pending.service_remove, cb, data);
116 }
117
118 /**
119  * Clears the value of the specified property.
120  *
121  *
122  * @param service path to call method on server.
123  * @param property to be cleared.
124  * @param cb function to call when server replies or some error happens.
125  * @param data data to give to cb when it is called.
126  *
127  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
128  */
129 Eina_Bool
130 e_connman_service_clear_property(E_Connman_Element *service, const char *property, E_DBus_Method_Return_Cb cb, const void *data)
131 {
132    const char name[] = "ClearProperty";
133
134    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
135    EINA_SAFETY_ON_NULL_RETURN_VAL(property, EINA_FALSE);
136    return e_connman_element_call_with_string
137              (service, name, property, NULL, &service->_pending.service_clear_property,
138              cb, data);
139 }
140
141 /**
142  * Move service before in favorites list.
143  *
144  * Call method MoveBefore(object service) at the given service on server.
145  *
146  * If a service has been used before, this allows a
147  * reorder of the favorite services.
148  *
149  * The target service object must be part of this
150  * profile. Moving between profiles is not supported.
151  *
152  * @param service path to call method on server.
153  * @param object_path object service.
154  * @param cb function to call when server replies or some error happens.
155  * @param data data to give to cb when it is called.
156  *
157  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
158  */
159 Eina_Bool
160 e_connman_service_move_before(E_Connman_Element *service, const char *object_path, E_DBus_Method_Return_Cb cb, const void *data)
161 {
162    const char name[] = "MoveBefore";
163
164    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
165    EINA_SAFETY_ON_NULL_RETURN_VAL(object_path, EINA_FALSE);
166    return e_connman_element_call_with_path
167              (service, name, object_path, NULL,
168              &service->_pending.service_move_before, cb, data);
169 }
170
171 /**
172  * Move service after in favorites list.
173  *
174  * Call method MoveAfter(object service) at the given service on server.
175  *
176  * If a service has been used before, this allows a
177  * reorder of the favorite services.
178  *
179  * The target service object must be part of this
180  * profile. Moving between profiles is not supported.
181  *
182  * @param service path to call method on server.
183  * @param cb function to call when server replies or some error happens.
184  * @param data data to give to cb when it is called.
185  *
186  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
187  */
188 Eina_Bool
189 e_connman_service_move_after(E_Connman_Element *service, const char *object_path, E_DBus_Method_Return_Cb cb, const void *data)
190 {
191    const char name[] = "MoveAfter";
192
193    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
194    EINA_SAFETY_ON_NULL_RETURN_VAL(object_path, EINA_FALSE);
195    return e_connman_element_call_with_path
196              (service, name, object_path, NULL,
197              &service->_pending.service_move_after, cb, data);
198 }
199
200 /**
201  * Get property "State" value.
202  *
203  * If this property isn't found then @c EINA_FALSE is returned.
204  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
205  * values shall be considered invalid.
206  *
207  * The service state information.
208  *
209  * Valid states are "idle", "failure", "association",
210  * "configuration", "ready", "login" and "online".
211  *
212  * @param service path to get property.
213  * @param state where to store the property value, must be a pointer
214  *        to string (const char **), it will not be allocated or
215  *        copied and references will be valid until element changes,
216  *        so copy it if you want to use it later.
217  *
218  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
219  */
220 Eina_Bool
221 e_connman_service_state_get(const E_Connman_Element *service, const char **state)
222 {
223    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
224    EINA_SAFETY_ON_NULL_RETURN_VAL(state, EINA_FALSE);
225    return e_connman_element_property_get_stringshared
226              (service, e_connman_prop_state, NULL, state);
227 }
228
229 /**
230  * Get property "Error" value.
231  *
232  * If this property isn't found then @c EINA_FALSE is returned.
233  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
234  * values shall be considered invalid.
235  *
236  * The service error status details.
237  *
238  * When error occur during connection or disconnection
239  * the detailed information are represented in this
240  * property to help the user interface to present the
241  * user with alternate options.
242  *
243  * This property is only valid when the service is in
244  * the "failure" state. Otherwise it might be empty or
245  * not present at all.
246  *
247  * Current defined error code is "dhcp-failed".
248  *
249  * @param service path to get property.
250  * @param error where to store the property value, must be a pointer
251  *        to string (const char **), it will not be allocated or
252  *        copied and references will be valid until element changes,
253  *        so copy it if you want to use it later.
254  *
255  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
256  */
257 Eina_Bool
258 e_connman_service_error_get(const E_Connman_Element *service, const char **error)
259 {
260    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
261    EINA_SAFETY_ON_NULL_RETURN_VAL(error, EINA_FALSE);
262    return e_connman_element_property_get_stringshared
263              (service, e_connman_prop_error, NULL, error);
264 }
265
266 /**
267  * Get property "Name" value.
268  *
269  * If this property isn't found then @c EINA_FALSE is returned.
270  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
271  * values shall be considered invalid.
272  *
273  * The service name (for example "Wireless" etc.)
274  *
275  * This name can be used for directly displaying it in
276  * the application. It has pure informational purpose.
277  *
278  * For Ethernet devices and hidden WiFi networks it is
279  * not guaranteed that this property is present.
280  *
281  * @param service path to get property.
282  * @param name where to store the property value, must be a pointer
283  *        to string (const char **), it will not be allocated or
284  *        copied and references will be valid until element changes,
285  *        so copy it if you want to use it later.
286  *
287  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
288  */
289 Eina_Bool
290 e_connman_service_name_get(const E_Connman_Element *service, const char **name)
291 {
292    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
293    EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
294    return e_connman_element_property_get_stringshared
295              (service, e_connman_prop_name, NULL, name);
296 }
297
298 /**
299  * Get property "Type" value.
300  *
301  * If this property isn't found then @c EINA_FALSE is returned.
302  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
303  * values shall be considered invalid.
304  *
305  * The service type (for example "ethernet", "wifi" etc.)
306  *
307  * This information should only be used to determine
308  * advanced properties or showing the correct icon
309  * to the user.
310  *
311  * @param service path to get property.
312  * @param type where to store the property value, must be a pointer
313  *        to string (const char **), it will not be allocated or
314  *        copied and references will be valid until element changes,
315  *        so copy it if you want to use it later.
316  *
317  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
318  */
319 Eina_Bool
320 e_connman_service_type_get(const E_Connman_Element *service, const char **type)
321 {
322    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
323    EINA_SAFETY_ON_NULL_RETURN_VAL(type, EINA_FALSE);
324    return e_connman_element_property_get_stringshared
325              (service, e_connman_prop_type, NULL, type);
326 }
327
328 /**
329  * Get property "Security" value.
330  *
331  * If this property isn't found then @c EINA_FALSE is returned.
332  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
333  * values shall be considered invalid.
334  *
335  * If the service type is WiFi, then this property is
336  * present and contains the list of security method or key
337  * management setting.
338  *
339  * Possible values are "none", "wep", "wpa", "rsn", "psk", "ieee8021x" and "wps"
340  *
341  * This property might be only present for WiFi
342  * services.
343  *
344  * @param service path to get property.
345  * @param security where to store the property value, must be a pointer
346  *        to E_Connman_Array, it will not be allocated or
347  *        copied and references will be valid until element changes,
348  *        so copy it if you want to use it later.
349  *
350  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
351  */
352 Eina_Bool
353 e_connman_service_security_get(const E_Connman_Element *service, const E_Connman_Array **security)
354 {
355    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
356    EINA_SAFETY_ON_NULL_RETURN_VAL(security, EINA_FALSE);
357    return e_connman_element_property_get_stringshared
358              (service, e_connman_prop_security, NULL, security);
359 }
360
361 /**
362  * Get property "Passphrase" value.
363  *
364  * If this property isn't found then @c EINA_FALSE is returned.
365  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
366  * values shall be considered invalid.
367  *
368  * If the service type is WiFi, then this property
369  * can be used to store a passphrase.
370  *
371  * No PropertyChanged signals will be send for this
372  * property. The PassphraseRequired property should
373  * be monitored instead.
374  *
375  * This property might also not always be included
376  * since it is protected by a different security policy.
377  *
378  * @param service path to get property.
379  * @param passphrase where to store the property value, must be a pointer
380  *        to string (const char **), it will not be allocated or
381  *        copied and references will be valid until element changes,
382  *        so copy it if you want to use it later.
383  *
384  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
385  * @see e_connman_service_passphrase_set()
386  */
387 Eina_Bool
388 e_connman_service_passphrase_get(const E_Connman_Element *service, const char **passphrase)
389 {
390    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
391    EINA_SAFETY_ON_NULL_RETURN_VAL(passphrase, EINA_FALSE);
392    return e_connman_element_property_get_stringshared
393              (service, e_connman_prop_passphrase, NULL, passphrase);
394 }
395
396 /**
397  * Set property "Passphrase" value.
398  *
399  * If this property isn't found then @c EINA_FALSE is returned.
400  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
401  * values shall be considered invalid.
402  *
403  * If the service type is WiFi, then this property
404  * can be used to store a passphrase.
405  *
406  * No PropertyChanged signals will be send for this
407  * property. The PassphraseRequired property should
408  * be monitored instead.
409  *
410  * This property might also not always be included
411  * since it is protected by a different security policy.
412  *
413  * @param service path to get property.
414  * @param passphrase value to set.
415  * @param cb function to call when server replies or some error happens.
416  * @param data data to give to cb when it is called.
417  *
418  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
419  * @see e_connman_service_passphrase_get()
420  */
421 Eina_Bool
422 e_connman_service_passphrase_set(E_Connman_Element *service, const char *passphrase, E_DBus_Method_Return_Cb cb, const void *data)
423 {
424    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
425    return e_connman_element_property_set_full
426              (service, e_connman_prop_passphrase, DBUS_TYPE_STRING,
427              passphrase, cb, data);
428 }
429
430 /**
431  * Get property "PassphraseRequired" value.
432  *
433  * If this property isn't found then @c EINA_FALSE is returned.
434  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
435  * values shall be considered invalid.
436  *
437  * If the service type is WiFi, then this property
438  * indicates if a passphrase is required.
439  *
440  * If a passphrase has been set already or if no
441  * passphrase is needed, then this property will
442  * be set to false.
443  *
444  * @param service path to get property.
445  * @param passphrase_required where to store the property value, must be a
446  *        pointer to Eina_Bool (Eina_Bool *).
447  *
448  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
449  */
450 Eina_Bool
451 e_connman_service_passphrase_required_get(const E_Connman_Element *service, Eina_Bool *passphrase_required)
452 {
453    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
454    EINA_SAFETY_ON_NULL_RETURN_VAL(passphrase_required, EINA_FALSE);
455    return e_connman_element_property_get_stringshared
456              (service, e_connman_prop_passphrase_required, NULL, passphrase_required);
457 }
458
459 /**
460  * Get property "LoginRequired" value.
461  *
462  * If this property isn't found then @c EINA_FALSE is returned.
463  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
464  * values shall be considered invalid.
465  *
466  * Indicates that a manual configuration must be done to login the
467  * user, likely access an website using a browser.
468  *
469  * If a login has been set already or if no
470  * login is needed, then this property will
471  * be set to false.
472  *
473  * @param service path to get property.
474  * @param login_required where to store the property value, must be a
475  *        pointer to Eina_Bool (Eina_Bool *).
476  *
477  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
478  *
479  * @since 1.1.0
480  */
481 Eina_Bool
482 e_connman_service_login_required_get(const E_Connman_Element *service, Eina_Bool *login_required)
483 {
484    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
485    EINA_SAFETY_ON_NULL_RETURN_VAL(login_required, EINA_FALSE);
486    return e_connman_element_property_get_stringshared
487              (service, e_connman_prop_login_required, NULL, login_required);
488 }
489
490 /**
491  * Get property "Strength" value.
492  *
493  * If this property isn't found then @c EINA_FALSE is returned.
494  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
495  * values shall be considered invalid.
496  *
497  * Indicates the signal strength of the service. This
498  * is a normalized value between 0 and 100.
499  *
500  * This property will not be present for Ethernet
501  * devices.
502  *
503  * @param service path to get property.
504  * @param strength where to store the property value, must be a pointer
505  *        to byte (unsigned char*).
506  *
507  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
508  */
509 Eina_Bool
510 e_connman_service_strength_get(const E_Connman_Element *service, unsigned char *strength)
511 {
512    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
513    EINA_SAFETY_ON_NULL_RETURN_VAL(strength, EINA_FALSE);
514    return e_connman_element_property_get_stringshared
515              (service, e_connman_prop_strength, NULL, strength);
516 }
517
518 /**
519  * Get property "Favorite" value.
520  *
521  * If this property isn't found then @c EINA_FALSE is returned.
522  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
523  * values shall be considered invalid.
524  *
525  * Will be true if a cable is plugged in or the user
526  * selected and successfully connected to this service.
527  *
528  * This value is automatically changed and to revert
529  * it back to false the Remove() method needs to be
530  * used.
531  *
532  * @param service path to get property.
533  * @param favorite where to store the property value, must be a
534  *        pointer to Eina_Bool (Eina_Bool *).
535  *
536  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
537  */
538 Eina_Bool
539 e_connman_service_favorite_get(const E_Connman_Element *service, Eina_Bool *favorite)
540 {
541    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
542    EINA_SAFETY_ON_NULL_RETURN_VAL(favorite, EINA_FALSE);
543    return e_connman_element_property_get_stringshared
544              (service, e_connman_prop_favorite, NULL, favorite);
545 }
546
547 /**
548  * Get property "Immutable" value.
549  *
550  * This value will be set to true if the service is configured
551  * externally via a configuration file.
552  *
553  * The only valid operation are e_connman_service_connect() and
554  * e_connman_service_disconnect(). The e_connman_service_remove()
555  * method will result in an error.
556
557  * @param service path to get property.
558  * @param immutable where to store the property value, must be a
559  *        pointer to Eina_Bool (Eina_Bool *).
560  *
561  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
562  */
563 Eina_Bool
564 e_connman_service_immutable_get(const E_Connman_Element *service, Eina_Bool *immutable)
565 {
566    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
567    EINA_SAFETY_ON_NULL_RETURN_VAL(immutable, EINA_FALSE);
568    return e_connman_element_property_get_stringshared
569              (service, e_connman_prop_immutable, NULL, immutable);
570 }
571
572 /**
573  * Get property "AutoConnect" value.
574  *
575  * If this property isn't found then @c EINA_FALSE is returned.
576  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
577  * values shall be considered invalid.
578  *
579  * If set to true, this service will auto-connect
580  * when not other connection is available.
581  *
582  * For favorite services it is possible to change
583  * this value to prevent or permit automatic
584  * connection attempts.
585  *
586  * @param service path to get property.
587  * @param auto_connect where to store the property value, must be a
588  *        pointer to Eina_Bool (Eina_Bool *).
589  *
590  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
591  * @see e_connman_service_auto_connect_set()
592  */
593 Eina_Bool
594 e_connman_service_auto_connect_get(const E_Connman_Element *service, Eina_Bool *auto_connect)
595 {
596    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
597    EINA_SAFETY_ON_NULL_RETURN_VAL(auto_connect, EINA_FALSE);
598    return e_connman_element_property_get_stringshared
599              (service, e_connman_prop_auto_connect, NULL, auto_connect);
600 }
601
602 /**
603  * Set property "AutoConnect" value.
604  *
605  * If this property isn't found then @c EINA_FALSE is returned.
606  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
607  * values shall be considered invalid.
608  *
609  * If set to true, this service will auto-connect
610  * when not other connection is available.
611  *
612  * For favorite services it is possible to change
613  * this value to prevent or permit automatic
614  * connection attempts.
615  *
616  * @param service path to get property.
617  * @param service_favorite where to store the property value, must be a
618  *        pointer to Eina_Bool (Eina_Bool *).
619  *
620  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
621  * @see e_connman_service_auto_connect_get()
622  */
623 Eina_Bool
624 e_connman_service_auto_connect_set(E_Connman_Element *service, Eina_Bool auto_connect, E_DBus_Method_Return_Cb cb, const void *data)
625 {
626    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
627    return e_connman_element_property_set_full
628              (service, e_connman_prop_auto_connect, DBUS_TYPE_BOOLEAN, &auto_connect, cb, data);
629 }
630
631 /**
632  * Get property "Roaming" value.
633  *
634  * If this property isn't found then @c EINA_FALSE is returned.
635  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
636  * values shall be considered invalid.
637  *
638  * This property indicates if this service is roaming.
639  *
640  * In the case of Cellular services this normally
641  * indicates connections to a foreign provider when
642  * traveling abroad.
643  *
644  * @param service path to get property.
645  * @param roaming where to store the property value, must be a
646  *        pointer to Eina_Bool (Eina_Bool *).
647  *
648  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
649  */
650 Eina_Bool
651 e_connman_service_roaming_get(const E_Connman_Element *service, Eina_Bool *roaming)
652 {
653    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
654    EINA_SAFETY_ON_NULL_RETURN_VAL(roaming, EINA_FALSE);
655    return e_connman_element_property_get_stringshared
656              (service, e_connman_prop_roaming, NULL, roaming);
657 }
658
659 /**
660  * Get property "Nameservers" value.
661  *
662  * If this property isn't found then @c EINA_FALSE is returned.
663  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
664  * values shall be considered invalid.
665  * The list of currently active nameservers for this service. If the server is
666  * not in READY or ONLINE state than this list will be empty.
667  *
668  * Global nameservers are automatically added to this list.
669  *
670  * The array represents a sorted list of the current nameservers. The first one
671  * has the highest priority and is used by default.
672  *
673  * When using DHCP this array represents the nameservers provided by the
674  * network. In case of manual settings, the ones from Nameservers.Configuration
675  * are used.
676  *
677  * @param service path to get property.
678  * @param count return the number of elements in array.
679  * @param nameservers array with pointers to internal strings. These
680  *        strings are not copied in any way, and they are granted to
681  *        be eina_stringshare instances, so one can use
682  *        eina_stringshare_ref() if he wants to save memory and cpu to
683  *        get an extra reference. The array itself is allocated using
684  *        malloc() and should be freed after usage is done. This
685  *        pointer is just set if return is @c EINA_TRUE.
686  *
687  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
688  */
689 Eina_Bool
690 e_connman_service_nameservers_get(const E_Connman_Element *service, unsigned int *count, const char ***nameservers)
691 {
692    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
693    EINA_SAFETY_ON_NULL_RETURN_VAL(nameservers, EINA_FALSE);
694    EINA_SAFETY_ON_NULL_RETURN_VAL(count, EINA_FALSE);
695    return e_connman_element_strings_array_get_stringshared
696              (service, e_connman_prop_nameservers, count, nameservers);
697 }
698
699 /**
700  * Get property "Domains" value.
701  *
702  * If this property isn't found then @c EINA_FALSE is returned.
703  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
704  * values shall be considered invalid.
705  * The list of currently active domains for this service. If the server is
706  * not in READY or ONLINE state than this list will be empty.
707  *
708  * The list of currently used search domains.
709  *
710  * @param service path to get property.
711  * @param count return the number of elements in array.
712  * @param domains array with pointers to internal strings. These
713  *        strings are not copied in any way, and they are granted to
714  *        be eina_stringshare instances, so one can use
715  *        eina_stringshare_ref() if he wants to save memory and cpu to
716  *        get an extra reference. The array itself is allocated using
717  *        malloc() and should be freed after usage is done. This
718  *        pointer is just set if return is @c EINA_TRUE.
719  *
720  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
721  */
722 Eina_Bool
723 e_connman_service_domains_get(const E_Connman_Element *service, unsigned int *count, const char ***domains)
724 {
725    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
726    EINA_SAFETY_ON_NULL_RETURN_VAL(domains, EINA_FALSE);
727    EINA_SAFETY_ON_NULL_RETURN_VAL(count, EINA_FALSE);
728    return e_connman_element_strings_array_get_stringshared
729              (service, e_connman_prop_domains, count, domains);
730 }
731 /**
732  * Get property "IPv4.Method" value.
733  *
734  * If this property isn't found then @c EINA_FALSE is returned.
735  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
736  * values shall be considered invalid.
737  *
738  * The IPv4 method in use. Possible values here are "dhcp" and
739  * "static".
740  *
741  * @param service path to get property.
742  * @param method where to store the property value, must be a pointer
743  *        to string (const char **), it will not be allocated or
744  *        copied and references will be valid until element changes,
745  *        so copy it if you want to use it later.
746  *
747  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
748  */
749 Eina_Bool
750 e_connman_service_ipv4_method_get(const E_Connman_Element *service, const char **method)
751 {
752    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
753    EINA_SAFETY_ON_NULL_RETURN_VAL(method, EINA_FALSE);
754    return e_connman_element_property_dict_get_stringshared
755              (service, e_connman_prop_ipv4, e_connman_prop_method, NULL, method);
756 }
757
758 /**
759  * Get property "IPv4.Address" value.
760  *
761  * If this property isn't found then @c EINA_FALSE is returned.
762  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
763  * values shall be considered invalid.
764  *
765  * The current IPv4 address.
766  *
767  * @param service path to get property.
768  * @param address where to store the property value, must be a pointer
769  *        to string (const char **), it will not be allocated or
770  *        copied and references will be valid until element changes,
771  *        so copy it if you want to use it later.
772  *
773  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
774  */
775 Eina_Bool
776 e_connman_service_ipv4_address_get(const E_Connman_Element *service, const char **address)
777 {
778    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
779    EINA_SAFETY_ON_NULL_RETURN_VAL(address, EINA_FALSE);
780    return e_connman_element_property_dict_get_stringshared
781              (service, e_connman_prop_ipv4, e_connman_prop_address, NULL, address);
782 }
783
784 /**
785  * Get property "IPv4.Gateway" value.
786  *
787  * If this property isn't found then @c EINA_FALSE is returned.
788  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
789  * values shall be considered invalid.
790  *
791  * The current IPv4 gateway.
792  *
793  * @param service path to get property.
794  * @param gateway where to store the property value, must be a pointer
795  *        to string (const char **), it will not be allocated or
796  *        copied and references will be valid until element changes,
797  *        so copy it if you want to use it later.
798  *
799  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
800  */
801 Eina_Bool
802 e_connman_service_ipv4_gateway_get(const E_Connman_Element *service, const char **gateway)
803 {
804    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
805    EINA_SAFETY_ON_NULL_RETURN_VAL(gateway, EINA_FALSE);
806    return e_connman_element_property_dict_get_stringshared
807              (service, e_connman_prop_ipv4, e_connman_prop_gateway, NULL, gateway);
808 }
809
810 /**
811  * Get property "IPv4.Netmask" value.
812  *
813  * If this property isn't found then @c EINA_FALSE is returned.
814  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
815  * values shall be considered invalid.
816  *
817  * The current IPv4 netmask.
818  *
819  * @param service path to get property.
820  * @param netmask where to store the property value, must be a pointer
821  *        to string (const char **), it will not be allocated or
822  *        copied and references will be valid until element changes,
823  *        so copy it if you want to use it later.
824  *
825  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
826  */
827 Eina_Bool
828 e_connman_service_ipv4_netmask_get(const E_Connman_Element *service, const char **netmask)
829 {
830    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
831    EINA_SAFETY_ON_NULL_RETURN_VAL(netmask, EINA_FALSE);
832    return e_connman_element_property_dict_get_stringshared
833              (service, e_connman_prop_ipv4, e_connman_prop_netmask, NULL, netmask);
834 }
835
836 /**
837  * Get property "IPv4.Configuration.Method" value.
838  *
839  * Unlike IPv4.Method, this is the user-set value, rather than the
840  * actual value.
841  *
842  * If this property isn't found then @c EINA_FALSE is returned.
843  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
844  * values shall be considered invalid.
845  *
846  * The IPv4 configured method. Possible values here are "dhcp" and
847  * "static".
848  *
849  * @param service path to get property.
850  * @param method where to store the property value, must be a pointer
851  *        to string (const char **), it will not be allocated or
852  *        copied and references will be valid until element changes,
853  *        so copy it if you want to use it later.
854  *
855  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
856  */
857 Eina_Bool
858 e_connman_service_ipv4_configuration_method_get(const E_Connman_Element *service, const char **method)
859 {
860    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
861    EINA_SAFETY_ON_NULL_RETURN_VAL(method, EINA_FALSE);
862    return e_connman_element_property_dict_get_stringshared
863              (service, e_connman_prop_ipv4_configuration, e_connman_prop_method,
864              NULL, method);
865 }
866
867 /**
868  * Get property "IPv4.Configuration.Address" value.
869  *
870  * Unlike IPv4.Address, this is the user-set value, rather than the
871  * actual value.
872  *
873  * If this property isn't found then @c EINA_FALSE is returned.
874  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
875  * values shall be considered invalid.
876  *
877  * The current configured IPv4 address.
878  *
879  * @param service path to get property.
880  * @param address where to store the property value, must be a pointer
881  *        to string (const char **), it will not be allocated or
882  *        copied and references will be valid until element changes,
883  *        so copy it if you want to use it later.
884  *
885  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
886  */
887 Eina_Bool
888 e_connman_service_ipv4_configuration_address_get(const E_Connman_Element *service, const char **address)
889 {
890    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
891    EINA_SAFETY_ON_NULL_RETURN_VAL(address, EINA_FALSE);
892    return e_connman_element_property_dict_get_stringshared
893              (service, e_connman_prop_ipv4_configuration, e_connman_prop_address,
894              NULL, address);
895 }
896
897 /**
898  * Get property "IPv4.Configuration.Gateway" value.
899  *
900  * Unlike IPv4.Gateway, this is the user-set value, rather than the
901  * actual value.
902  *
903  * If this property isn't found then @c EINA_FALSE is returned.
904  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
905  * values shall be considered invalid.
906  *
907  * The current configured IPv4 gateway.
908  *
909  * @param service path to get property.
910  * @param gateway where to store the property value, must be a pointer
911  *        to string (const char **), it will not be allocated or
912  *        copied and references will be valid until element changes,
913  *        so copy it if you want to use it later.
914  *
915  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
916  */
917 Eina_Bool
918 e_connman_service_ipv4_configuration_gateway_get(const E_Connman_Element *service, const char **gateway)
919 {
920    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
921    EINA_SAFETY_ON_NULL_RETURN_VAL(gateway, EINA_FALSE);
922    return e_connman_element_property_dict_get_stringshared
923              (service, e_connman_prop_ipv4_configuration, e_connman_prop_gateway,
924              NULL, gateway);
925 }
926
927 /**
928  * Get property "IPv4.Configuration.Netmask" value.
929  *
930  * Unlike IPv4.Netmask, this is the user-set value, rather than the
931  * actual value.
932  *
933  * If this property isn't found then @c EINA_FALSE is returned.
934  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
935  * values shall be considered invalid.
936  *
937  * The current configured IPv4 netmask.
938  *
939  * @param service path to get property.
940  * @param netmask where to store the property value, must be a pointer
941  *        to string (const char **), it will not be allocated or
942  *        copied and references will be valid until element changes,
943  *        so copy it if you want to use it later.
944  *
945  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
946  */
947 Eina_Bool
948 e_connman_service_ipv4_configuration_netmask_get(const E_Connman_Element *service, const char **netmask)
949 {
950    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
951    EINA_SAFETY_ON_NULL_RETURN_VAL(netmask, EINA_FALSE);
952    return e_connman_element_property_dict_get_stringshared
953              (service, e_connman_prop_ipv4_configuration, e_connman_prop_netmask,
954              NULL, netmask);
955 }
956
957 /**
958  * Set IPv4 to connect automatically using DHCP.
959  *
960  * @param service path to set.
961  * @param cb function to call when server replies or some error happens.
962  * @param data data to give to cb when it is called.
963  *
964  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
965  */
966 Eina_Bool
967 e_connman_service_ipv4_configure_dhcp(E_Connman_Element *service, E_DBus_Method_Return_Cb cb, const void *data)
968 {
969    const char method[] = "dhcp";
970    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
971    return e_connman_element_property_dict_set_full
972              (service, e_connman_prop_ipv4_configuration, e_connman_prop_method,
973              DBUS_TYPE_STRING, method, cb, data);
974 }
975
976 /**
977  * Set IPv4 to connect using manually set parameters.
978  *
979  * @param service path to set.
980  * @param address IPv4 address.
981  * @param netmask IPv4 netmask, or @c NULL for "/32".
982  * @param gateway IPv4 gateway address.
983  * @param cb function to call when server replies or some error happens.
984  * @param data data to give to cb when it is called.
985  *
986  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
987  */
988 Eina_Bool
989 e_connman_service_ipv4_configure_manual(E_Connman_Element *service, const char *address, const char *netmask, const char *gateway, E_DBus_Method_Return_Cb cb, const void *data)
990 {
991    const char name[] = "SetProperty";
992    const char *method = "manual"; /* not method[] as gcc screws it with dbus */
993    DBusMessage *msg;
994    DBusMessageIter itr, variant, dict, entry;
995
996    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
997    EINA_SAFETY_ON_NULL_RETURN_VAL(address, EINA_FALSE);
998
999    msg = dbus_message_new_method_call
1000          (e_connman_system_bus_name_get(), service->path, service->interface, name);
1001
1002    if (!msg)
1003       return 0;
1004
1005    dbus_message_iter_init_append(msg, &itr);
1006    dbus_message_iter_append_basic
1007       (&itr, DBUS_TYPE_STRING, &e_connman_prop_ipv4_configuration);
1008
1009    dbus_message_iter_open_container
1010       (&itr, DBUS_TYPE_VARIANT,
1011       (DBUS_TYPE_ARRAY_AS_STRING
1012        DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1013        DBUS_TYPE_STRING_AS_STRING
1014        DBUS_TYPE_STRING_AS_STRING
1015        DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
1016       &variant);
1017    dbus_message_iter_open_container
1018       (&variant, DBUS_TYPE_ARRAY,
1019       (DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
1020        DBUS_TYPE_STRING_AS_STRING
1021        DBUS_TYPE_STRING_AS_STRING
1022        DBUS_DICT_ENTRY_END_CHAR_AS_STRING),
1023       &dict);
1024
1025    dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1026    dbus_message_iter_append_basic
1027       (&entry, DBUS_TYPE_STRING, &e_connman_prop_method);
1028    dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &method);
1029    dbus_message_iter_close_container(&dict, &entry);
1030
1031    dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1032    dbus_message_iter_append_basic
1033       (&entry, DBUS_TYPE_STRING, &e_connman_prop_address);
1034    dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &address);
1035    dbus_message_iter_close_container(&dict, &entry);
1036
1037    if (netmask)
1038      {
1039         dbus_message_iter_open_container
1040            (&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1041         dbus_message_iter_append_basic
1042            (&entry, DBUS_TYPE_STRING, &e_connman_prop_netmask);
1043         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &netmask);
1044         dbus_message_iter_close_container(&dict, &entry);
1045      }
1046
1047    if (gateway)
1048      {
1049         dbus_message_iter_open_container
1050            (&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry);
1051         dbus_message_iter_append_basic
1052            (&entry, DBUS_TYPE_STRING, &e_connman_prop_gateway);
1053         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &gateway);
1054         dbus_message_iter_close_container(&dict, &entry);
1055      }
1056
1057    dbus_message_iter_close_container(&variant, &dict);
1058    dbus_message_iter_close_container(&itr, &variant);
1059
1060    return e_connman_element_message_send
1061              (service, name, NULL, msg, &service->_pending.property_set, cb, data);
1062 }
1063
1064 /**
1065  * Get property "Proxy.Method" value.
1066  *
1067  * If this property isn't found then @c EINA_FALSE is returned.
1068  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1069  * values shall be considered invalid.
1070  *
1071  * Possible values are "direct", "auto" and "manual".
1072  *
1073  * @param service path to get property.
1074  * @param method where to store the property value, must be a pointer
1075  *        to string (const char **), it will not be allocated or
1076  *        copied and references will be valid until element changes,
1077  *        so copy it if you want to use it later.
1078  *
1079  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1080  */
1081 Eina_Bool
1082 e_connman_service_proxy_method_get(const E_Connman_Element *service, const char **method)
1083 {
1084    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1085    EINA_SAFETY_ON_NULL_RETURN_VAL(method, EINA_FALSE);
1086    return e_connman_element_property_dict_get_stringshared
1087              (service, e_connman_prop_proxy, e_connman_prop_method, NULL, method);
1088 }
1089
1090 /**
1091  * Get property "Proxy.URL" value.
1092  *
1093  * If this property isn't found then @c EINA_FALSE is returned.
1094  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1095  * values shall be considered invalid.
1096  *
1097  * Automatic proxy configuration URL. Used by "auto" method.
1098  *
1099  * @param service path to get property.
1100  * @param url where to store the property value, must be a pointer
1101  *        to string (const char **), it will not be allocated or
1102  *        copied and references will be valid until element changes,
1103  *        so copy it if you want to use it later.
1104  *
1105  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1106  */
1107 Eina_Bool
1108 e_connman_service_proxy_url_get(const E_Connman_Element *service, const char **url)
1109 {
1110    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1111    EINA_SAFETY_ON_NULL_RETURN_VAL(url, EINA_FALSE);
1112    return e_connman_element_property_dict_get_stringshared
1113              (service, e_connman_prop_proxy, e_connman_prop_url, NULL, url);
1114 }
1115
1116 /**
1117  * Get property "Proxy.Servers" value.
1118  *
1119  * If this property isn't found then @c EINA_FALSE is returned.
1120  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1121  * values shall be considered invalid.
1122  *
1123  * List of proxy URIs. The URI without a protocol will be interpreted as the
1124  * generic proxy URI. All others will target a specific protocol and only once.
1125  * Example of generic proxy server entry would be like this:
1126  * "server.example.com:911".
1127  *
1128  * Used when "manual" method is set.
1129  *
1130  * @param service path to get property.
1131  * @param count return the number of elements in array.
1132  * @param servers array with pointers to internal strings. These
1133  *        strings are not copied in any way, and they are granted to
1134  *        be eina_stringshare instances, so one can use
1135  *        eina_stringshare_ref() if he wants to save memory and cpu to
1136  *        get an extra reference. The array itself is allocated using
1137  *        malloc() and should be freed after usage is done. This
1138  *        pointer is just set if return is @c EINA_TRUE.
1139  *
1140  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1141  */
1142 Eina_Bool
1143 e_connman_service_proxy_servers_get(const E_Connman_Element *service, unsigned int *count, const char ***servers)
1144 {
1145    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1146    EINA_SAFETY_ON_NULL_RETURN_VAL(servers, EINA_FALSE);
1147    EINA_SAFETY_ON_NULL_RETURN_VAL(count, EINA_FALSE);
1148    return e_connman_element_property_dict_strings_array_get_stringshared
1149              (service, e_connman_prop_proxy, e_connman_prop_servers, count, servers);
1150 }
1151
1152 /**
1153  * Get property "Proxy.Excludes" value.
1154  *
1155  * If this property isn't found then @c EINA_FALSE is returned.
1156  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1157  * values shall be considered invalid.
1158  *
1159  * List of hosts which can be accessed directly.
1160  *
1161  * Used when "manual" method is set.
1162  *
1163  * @param service path to get property.
1164  * @param count return the number of elements in array.
1165  * @param excludes array with pointers to internal strings. These
1166  *        strings are not copied in any way, and they are granted to
1167  *        be eina_stringshare instances, so one can use
1168  *        eina_stringshare_ref() if he wants to save memory and cpu to
1169  *        get an extra reference. The array itself is allocated using
1170  *        malloc() and should be freed after usage is done. This
1171  *        pointer is just set if return is @c EINA_TRUE.
1172  *
1173  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1174  */
1175 Eina_Bool
1176 e_connman_service_proxy_excludes_get(const E_Connman_Element *service, unsigned int *count, const char ***excludes)
1177 {
1178    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1179    EINA_SAFETY_ON_NULL_RETURN_VAL(excludes, EINA_FALSE);
1180    EINA_SAFETY_ON_NULL_RETURN_VAL(count, EINA_FALSE);
1181    return e_connman_element_property_dict_strings_array_get_stringshared
1182              (service, e_connman_prop_proxy, e_connman_prop_excludes, count, excludes);
1183 }
1184
1185 /**
1186  * Get property "Ethernet.Interface" value.
1187  *
1188  * If this property isn't found then @c EINA_FALSE is returned.
1189  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1190  * values shall be considered invalid.
1191  *
1192  * Interface name (for example eth0).
1193  *
1194  * @param service path to get property.
1195  * @param iface where to store the property value, must be a pointer
1196  *        to string (const char **), it will not be allocated or
1197  *        copied and references will be valid until element changes,
1198  *        so copy it if you want to use it later.
1199  *
1200  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1201  */
1202 Eina_Bool
1203 e_connman_service_ethernet_interface_get(const E_Connman_Element *service, const char **iface)
1204 {
1205    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1206    EINA_SAFETY_ON_NULL_RETURN_VAL(iface, EINA_FALSE);
1207    return e_connman_element_property_dict_get_stringshared
1208              (service, e_connman_prop_ethernet, e_connman_prop_interface, NULL, iface);
1209 }
1210
1211 /**
1212  * Get property "Ethernet.Method" value.
1213  *
1214  * If this property isn't found then @c EINA_FALSE is returned.
1215  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1216  * values shall be considered invalid.
1217  *
1218  * The Ethernet configuration method. Possible values here "auto" and "manual".
1219  *
1220  * @param service path to get property.
1221  * @param method where to store the property value, must be a pointer
1222  *        to string (const char **), it will not be allocated or
1223  *        copied and references will be valid until element changes,
1224  *        so copy it if you want to use it later.
1225  *
1226  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1227  */
1228 Eina_Bool
1229 e_connman_service_ethernet_method_get(const E_Connman_Element *service, const char **method)
1230 {
1231    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1232    EINA_SAFETY_ON_NULL_RETURN_VAL(method, EINA_FALSE);
1233    return e_connman_element_property_dict_get_stringshared
1234              (service, e_connman_prop_ethernet, e_connman_prop_method, NULL, method);
1235 }
1236
1237 /**
1238  * Get property "Ethernet.Speed" value.
1239  *
1240  * If this property isn't found then @c EINA_FALSE is returned.
1241  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1242  * values shall be considered invalid.
1243  *
1244  * Selected speed of the line. This information might not always be available.
1245  *
1246  * @param service path to get property.
1247  * @param speed where to store the property value.
1248  *
1249  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1250  */
1251 Eina_Bool
1252 e_connman_service_ethernet_speed_get(const E_Connman_Element *service, unsigned short *speed)
1253 {
1254    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1255    EINA_SAFETY_ON_NULL_RETURN_VAL(speed, EINA_FALSE);
1256    return e_connman_element_property_dict_get_stringshared
1257              (service, e_connman_prop_ethernet, e_connman_prop_speed, NULL, speed);
1258 }
1259
1260 /**
1261  * Get property "Ethernet.Address" value.
1262  *
1263  * If this property isn't found then @c EINA_FALSE is returned.
1264  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1265  * values shall be considered invalid.
1266  *
1267  * The current configured Ethernet address (mac-address).
1268  *
1269  * @param service path to get property.
1270  * @param address where to store the property value, must be a pointer
1271  *        to string (const char **), it will not be allocated or
1272  *        copied and references will be valid until element changes,
1273  *        so copy it if you want to use it later.
1274  *
1275  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1276  */
1277 Eina_Bool
1278 e_connman_service_ethernet_address_get(const E_Connman_Element *service, const char **address)
1279 {
1280    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1281    EINA_SAFETY_ON_NULL_RETURN_VAL(address, EINA_FALSE);
1282    return e_connman_element_property_dict_get_stringshared
1283              (service, e_connman_prop_ethernet, e_connman_prop_address, NULL, address);
1284 }
1285
1286 /**
1287  * Get property "Ethernet.Duplex" value.
1288  *
1289  * If this property isn't found then @c EINA_FALSE is returned.
1290  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1291  * values shall be considered invalid.
1292  *
1293  * Selected duplex settings of the line. Possible values are "half" and "full".
1294  * This information might not always be available.
1295  *
1296  * @param service path to get property.
1297  * @param duplex where to store the property value, must be a pointer
1298  *        to string (const char **), it will not be allocated or
1299  *        copied and references will be valid until element changes,
1300  *        so copy it if you want to use it later.
1301  *
1302  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1303  */
1304 Eina_Bool
1305 e_connman_service_ethernet_duplex_get(const E_Connman_Element *service, const char **duplex)
1306 {
1307    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1308    EINA_SAFETY_ON_NULL_RETURN_VAL(duplex, EINA_FALSE);
1309    return e_connman_element_property_dict_get_stringshared
1310              (service, e_connman_prop_ethernet, e_connman_prop_duplex, NULL, duplex);
1311 }
1312
1313 /**
1314  * Get property "Ethernet.MTU" value.
1315  *
1316  * If this property isn't found then @c EINA_FALSE is returned.
1317  * If @c EINA_FALSE is returned, then this call failed and parameter-returned
1318  * values shall be considered invalid.
1319  *
1320  * The current configured Ethernet MTU.
1321  *
1322  * @param service path to get property.
1323  * @param gateway where to store the property value, must be a pointer
1324  *        to string (const char **), it will not be allocated or
1325  *        copied and references will be valid until element changes,
1326  *        so copy it if you want to use it later.
1327  *
1328  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise.
1329  */
1330 Eina_Bool
1331 e_connman_service_ethernet_mtu_get(const E_Connman_Element *service, unsigned short *mtu)
1332 {
1333    EINA_SAFETY_ON_NULL_RETURN_VAL(service, EINA_FALSE);
1334    EINA_SAFETY_ON_NULL_RETURN_VAL(mtu, EINA_FALSE);
1335    return e_connman_element_property_dict_get_stringshared
1336              (service, e_connman_prop_ethernet, e_connman_prop_mtu, NULL, mtu);
1337 }