connman-ui-0_20150622+dfsg.orig/0000755000175000017500000000000012541725135014555 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/ChangeLog0000644000175000017500000000032712541725135016331 0ustar nicknick2012-09-18 gettextize * Makefile.am (SUBDIRS): Add intl. (ACLOCAL_AMFLAGS): New variable. (EXTRA_DIST): New variable. * configure.ac (AC_OUTPUT): Add intl/Makefile, po/Makefile.in. connman-ui-0_20150622+dfsg.orig/gdbus/0000755000175000017500000000000012541725135015661 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/gdbus/polkit.c0000644000175000017500000001262012541725135017330 0ustar nicknick/* * * D-Bus helper library * * Copyright (C) 2004-2011 Marcel Holtmann * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include int polkit_check_authorization(DBusConnection *conn, const char *action, gboolean interaction, void (*function) (dbus_bool_t authorized, void *user_data), void *user_data, int timeout); static void add_dict_with_string_value(DBusMessageIter *iter, const char *key, const char *str) { DBusMessageIter dict, entry, value; dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &value); dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str); dbus_message_iter_close_container(&entry, &value); dbus_message_iter_close_container(&dict, &entry); dbus_message_iter_close_container(iter, &dict); } static void add_empty_string_dict(DBusMessageIter *iter) { DBusMessageIter dict; dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); dbus_message_iter_close_container(iter, &dict); } static void add_arguments(DBusConnection *conn, DBusMessageIter *iter, const char *action, dbus_uint32_t flags) { const char *busname = dbus_bus_get_unique_name(conn); const char *kind = "system-bus-name"; const char *cancel = ""; DBusMessageIter subject; dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &subject); dbus_message_iter_append_basic(&subject, DBUS_TYPE_STRING, &kind); add_dict_with_string_value(&subject, "name", busname); dbus_message_iter_close_container(iter, &subject); dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &action); add_empty_string_dict(iter); dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &flags); dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &cancel); } static dbus_bool_t parse_result(DBusMessageIter *iter) { DBusMessageIter result; dbus_bool_t authorized, challenge; dbus_message_iter_recurse(iter, &result); dbus_message_iter_get_basic(&result, &authorized); dbus_message_iter_get_basic(&result, &challenge); return authorized; } struct authorization_data { void (*function) (dbus_bool_t authorized, void *user_data); void *user_data; }; static void authorization_reply(DBusPendingCall *call, void *user_data) { struct authorization_data *data = user_data; DBusMessage *reply; DBusMessageIter iter; dbus_bool_t authorized = FALSE; reply = dbus_pending_call_steal_reply(call); if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) goto done; if (dbus_message_has_signature(reply, "(bba{ss})") == FALSE) goto done; dbus_message_iter_init(reply, &iter); authorized = parse_result(&iter); done: if (data->function != NULL) data->function(authorized, data->user_data); dbus_message_unref(reply); dbus_pending_call_unref(call); } #define AUTHORITY_DBUS "org.freedesktop.PolicyKit1" #define AUTHORITY_INTF "org.freedesktop.PolicyKit1.Authority" #define AUTHORITY_PATH "/org/freedesktop/PolicyKit1/Authority" int polkit_check_authorization(DBusConnection *conn, const char *action, gboolean interaction, void (*function) (dbus_bool_t authorized, void *user_data), void *user_data, int timeout) { struct authorization_data *data; DBusMessage *msg; DBusMessageIter iter; DBusPendingCall *call; dbus_uint32_t flags = 0x00000000; if (conn == NULL) return -EINVAL; data = dbus_malloc0(sizeof(*data)); if (data == NULL) return -ENOMEM; msg = dbus_message_new_method_call(AUTHORITY_DBUS, AUTHORITY_PATH, AUTHORITY_INTF, "CheckAuthorization"); if (msg == NULL) { dbus_free(data); return -ENOMEM; } if (interaction == TRUE) flags |= 0x00000001; if (action == NULL) action = "org.freedesktop.policykit.exec"; dbus_message_iter_init_append(msg, &iter); add_arguments(conn, &iter, action, flags); if (dbus_connection_send_with_reply(conn, msg, &call, timeout) == FALSE) { dbus_message_unref(msg); dbus_free(data); return -EIO; } if (call == NULL) { dbus_message_unref(msg); dbus_free(data); return -EIO; } data->function = function; data->user_data = user_data; dbus_pending_call_set_notify(call, authorization_reply, data, dbus_free); dbus_message_unref(msg); return 0; } connman-ui-0_20150622+dfsg.orig/gdbus/object.c0000644000175000017500000012553512541725135017306 0ustar nicknick/* * * D-Bus helper library * * Copyright (C) 2004-2011 Marcel Holtmann * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include "gdbus.h" #define info(fmt...) #define error(fmt...) #define debug(fmt...) #define DBUS_INTERFACE_OBJECT_MANAGER "org.freedesktop.DBus.ObjectManager" #ifndef DBUS_ERROR_UNKNOWN_PROPERTY #define DBUS_ERROR_UNKNOWN_PROPERTY "org.freedesktop.DBus.Error.UnknownProperty" #endif #ifndef DBUS_ERROR_PROPERTY_READ_ONLY #define DBUS_ERROR_PROPERTY_READ_ONLY "org.freedesktop.DBus.Error.PropertyReadOnly" #endif struct generic_data { unsigned int refcount; DBusConnection *conn; char *path; GSList *interfaces; GSList *objects; GSList *added; GSList *removed; guint process_id; gboolean pending_prop; char *introspect; struct generic_data *parent; }; struct interface_data { char *name; const GDBusMethodTable *methods; const GDBusSignalTable *signals; const GDBusPropertyTable *properties; GSList *pending_prop; void *user_data; GDBusDestroyFunction destroy; }; struct security_data { GDBusPendingReply pending; DBusMessage *message; const GDBusMethodTable *method; void *iface_user_data; }; struct property_data { DBusConnection *conn; GDBusPendingPropertySet id; DBusMessage *message; }; static int global_flags = 0; static struct generic_data *root; static gboolean process_changes(gpointer user_data); static void process_properties_from_interface(struct generic_data *data, struct interface_data *iface); static void process_property_changes(struct generic_data *data); static void print_arguments(GString *gstr, const GDBusArgInfo *args, const char *direction) { for (; args && args->name; args++) { g_string_append_printf(gstr, "\t\t\tname, args->signature); if (direction) g_string_append_printf(gstr, " direction=\"%s\"/>\n", direction); else g_string_append_printf(gstr, "/>\n"); } } #define G_DBUS_ANNOTATE(prefix_, name_, value_) \ prefix_ "\n" #define G_DBUS_ANNOTATE_DEPRECATED(prefix_) \ G_DBUS_ANNOTATE(prefix_, "Deprecated", "true") #define G_DBUS_ANNOTATE_NOREPLY(prefix_) \ G_DBUS_ANNOTATE(prefix_, "Method.NoReply", "true") static gboolean check_experimental(int flags, int flag) { if (!(flags & flag)) return FALSE; return !(global_flags & G_DBUS_FLAG_ENABLE_EXPERIMENTAL); } static void generate_interface_xml(GString *gstr, struct interface_data *iface) { const GDBusMethodTable *method; const GDBusSignalTable *signal; const GDBusPropertyTable *property; for (method = iface->methods; method && method->name; method++) { gboolean deprecated = method->flags & G_DBUS_METHOD_FLAG_DEPRECATED; gboolean noreply = method->flags & G_DBUS_METHOD_FLAG_NOREPLY; if (check_experimental(method->flags, G_DBUS_METHOD_FLAG_EXPERIMENTAL)) continue; if (!deprecated && !noreply && !(method->in_args && method->in_args->name) && !(method->out_args && method->out_args->name)) g_string_append_printf(gstr, "\t\t\n", method->name); else { g_string_append_printf(gstr, "\t\t\n", method->name); print_arguments(gstr, method->in_args, "in"); print_arguments(gstr, method->out_args, "out"); if (deprecated) g_string_append_printf(gstr, G_DBUS_ANNOTATE_DEPRECATED("\t\t\t")); if (noreply) g_string_append_printf(gstr, G_DBUS_ANNOTATE_NOREPLY("\t\t\t")); g_string_append_printf(gstr, "\t\t\n"); } } for (signal = iface->signals; signal && signal->name; signal++) { gboolean deprecated = signal->flags & G_DBUS_SIGNAL_FLAG_DEPRECATED; if (check_experimental(signal->flags, G_DBUS_SIGNAL_FLAG_EXPERIMENTAL)) continue; if (!deprecated && !(signal->args && signal->args->name)) g_string_append_printf(gstr, "\t\t\n", signal->name); else { g_string_append_printf(gstr, "\t\t\n", signal->name); print_arguments(gstr, signal->args, NULL); if (deprecated) g_string_append_printf(gstr, G_DBUS_ANNOTATE_DEPRECATED("\t\t\t")); g_string_append_printf(gstr, "\t\t\n"); } } for (property = iface->properties; property && property->name; property++) { gboolean deprecated = property->flags & G_DBUS_PROPERTY_FLAG_DEPRECATED; if (check_experimental(property->flags, G_DBUS_PROPERTY_FLAG_EXPERIMENTAL)) continue; g_string_append_printf(gstr, "\t\tname, property->type, property->get ? "read" : "", property->set ? "write" : ""); if (!deprecated) g_string_append_printf(gstr, "/>\n"); else g_string_append_printf(gstr, G_DBUS_ANNOTATE_DEPRECATED(">\n\t\t\t")); } } static void generate_introspection_xml(DBusConnection *conn, struct generic_data *data, const char *path) { GSList *list; GString *gstr; char **children; int i; g_free(data->introspect); gstr = g_string_new(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE); g_string_append_printf(gstr, "\n"); for (list = data->interfaces; list; list = list->next) { struct interface_data *iface = list->data; g_string_append_printf(gstr, "\t\n", iface->name); generate_interface_xml(gstr, iface); g_string_append_printf(gstr, "\t\n"); } if (!dbus_connection_list_registered(conn, path, &children)) goto done; for (i = 0; children[i]; i++) g_string_append_printf(gstr, "\t\n", children[i]); dbus_free_string_array(children); done: g_string_append_printf(gstr, "\n"); data->introspect = g_string_free(gstr, FALSE); } static DBusMessage *introspect(DBusConnection *connection, DBusMessage *message, void *user_data) { struct generic_data *data = user_data; DBusMessage *reply; if (data->introspect == NULL) generate_introspection_xml(connection, data, dbus_message_get_path(message)); reply = dbus_message_new_method_return(message); if (reply == NULL) return NULL; dbus_message_append_args(reply, DBUS_TYPE_STRING, &data->introspect, DBUS_TYPE_INVALID); return reply; } static DBusHandlerResult process_message(DBusConnection *connection, DBusMessage *message, const GDBusMethodTable *method, void *iface_user_data) { DBusMessage *reply; reply = method->function(connection, message, iface_user_data); if (method->flags & G_DBUS_METHOD_FLAG_NOREPLY) { if (reply != NULL) dbus_message_unref(reply); return DBUS_HANDLER_RESULT_HANDLED; } if (method->flags & G_DBUS_METHOD_FLAG_ASYNC) { if (reply == NULL) return DBUS_HANDLER_RESULT_HANDLED; } if (reply == NULL) return DBUS_HANDLER_RESULT_NEED_MEMORY; dbus_connection_send(connection, reply, NULL); dbus_message_unref(reply); return DBUS_HANDLER_RESULT_HANDLED; } static GDBusPendingReply next_pending = 1; static GSList *pending_security = NULL; static const GDBusSecurityTable *security_table = NULL; void g_dbus_pending_success(DBusConnection *connection, GDBusPendingReply pending) { GSList *list; for (list = pending_security; list; list = list->next) { struct security_data *secdata = list->data; if (secdata->pending != pending) continue; pending_security = g_slist_remove(pending_security, secdata); process_message(connection, secdata->message, secdata->method, secdata->iface_user_data); dbus_message_unref(secdata->message); g_free(secdata); return; } } void g_dbus_pending_error_valist(DBusConnection *connection, GDBusPendingReply pending, const char *name, const char *format, va_list args) { GSList *list; for (list = pending_security; list; list = list->next) { struct security_data *secdata = list->data; DBusMessage *reply; if (secdata->pending != pending) continue; pending_security = g_slist_remove(pending_security, secdata); reply = g_dbus_create_error_valist(secdata->message, name, format, args); if (reply != NULL) { dbus_connection_send(connection, reply, NULL); dbus_message_unref(reply); } dbus_message_unref(secdata->message); g_free(secdata); return; } } void g_dbus_pending_error(DBusConnection *connection, GDBusPendingReply pending, const char *name, const char *format, ...) { va_list args; va_start(args, format); g_dbus_pending_error_valist(connection, pending, name, format, args); va_end(args); } int polkit_check_authorization(DBusConnection *conn, const char *action, gboolean interaction, void (*function) (dbus_bool_t authorized, void *user_data), void *user_data, int timeout); struct builtin_security_data { DBusConnection *conn; GDBusPendingReply pending; }; static void builtin_security_result(dbus_bool_t authorized, void *user_data) { struct builtin_security_data *data = user_data; if (authorized == TRUE) g_dbus_pending_success(data->conn, data->pending); else g_dbus_pending_error(data->conn, data->pending, DBUS_ERROR_AUTH_FAILED, NULL); g_free(data); } static void builtin_security_function(DBusConnection *conn, const char *action, gboolean interaction, GDBusPendingReply pending) { struct builtin_security_data *data; data = g_new0(struct builtin_security_data, 1); data->conn = conn; data->pending = pending; if (polkit_check_authorization(conn, action, interaction, builtin_security_result, data, 30000) < 0) g_dbus_pending_error(conn, pending, NULL, NULL); } static gboolean check_privilege(DBusConnection *conn, DBusMessage *msg, const GDBusMethodTable *method, void *iface_user_data) { const GDBusSecurityTable *security; for (security = security_table; security && security->privilege; security++) { struct security_data *secdata; gboolean interaction; if (security->privilege != method->privilege) continue; secdata = g_new(struct security_data, 1); secdata->pending = next_pending++; secdata->message = dbus_message_ref(msg); secdata->method = method; secdata->iface_user_data = iface_user_data; pending_security = g_slist_prepend(pending_security, secdata); if (security->flags & G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION) interaction = TRUE; else interaction = FALSE; if (!(security->flags & G_DBUS_SECURITY_FLAG_BUILTIN) && security->function) security->function(conn, security->action, interaction, secdata->pending); else builtin_security_function(conn, security->action, interaction, secdata->pending); return TRUE; } return FALSE; } static GDBusPendingPropertySet next_pending_property = 1; static GSList *pending_property_set; static struct property_data *remove_pending_property_data( GDBusPendingPropertySet id) { struct property_data *propdata; GSList *l; for (l = pending_property_set; l != NULL; l = l->next) { propdata = l->data; if (propdata->id != id) continue; break; } if (l == NULL) return NULL; pending_property_set = g_slist_delete_link(pending_property_set, l); return propdata; } void g_dbus_pending_property_success(GDBusPendingPropertySet id) { struct property_data *propdata; propdata = remove_pending_property_data(id); if (propdata == NULL) return; g_dbus_send_reply(propdata->conn, propdata->message, DBUS_TYPE_INVALID); dbus_message_unref(propdata->message); g_free(propdata); } void g_dbus_pending_property_error_valist(GDBusPendingReply id, const char *name, const char *format, va_list args) { struct property_data *propdata; DBusMessage *reply; propdata = remove_pending_property_data(id); if (propdata == NULL) return; reply = g_dbus_create_error_valist(propdata->message, name, format, args); if (reply != NULL) { dbus_connection_send(propdata->conn, reply, NULL); dbus_message_unref(reply); } dbus_message_unref(propdata->message); g_free(propdata); } void g_dbus_pending_property_error(GDBusPendingReply id, const char *name, const char *format, ...) { va_list args; va_start(args, format); g_dbus_pending_property_error_valist(id, name, format, args); va_end(args); } static void reset_parent(gpointer data, gpointer user_data) { struct generic_data *child = data; struct generic_data *parent = user_data; child->parent = parent; } static void append_property(struct interface_data *iface, const GDBusPropertyTable *p, DBusMessageIter *dict) { DBusMessageIter entry, value; dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &p->name); dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, p->type, &value); p->get(p, &value, iface->user_data); dbus_message_iter_close_container(&entry, &value); dbus_message_iter_close_container(dict, &entry); } static void append_properties(struct interface_data *data, DBusMessageIter *iter) { DBusMessageIter dict; const GDBusPropertyTable *p; dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); for (p = data->properties; p && p->name; p++) { if (check_experimental(p->flags, G_DBUS_PROPERTY_FLAG_EXPERIMENTAL)) continue; if (p->get == NULL) continue; if (p->exists != NULL && !p->exists(p, data->user_data)) continue; append_property(data, p, &dict); } dbus_message_iter_close_container(iter, &dict); } static void append_interface(gpointer data, gpointer user_data) { struct interface_data *iface = data; DBusMessageIter *array = user_data; DBusMessageIter entry; dbus_message_iter_open_container(array, DBUS_TYPE_DICT_ENTRY, NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &iface->name); append_properties(data, &entry); dbus_message_iter_close_container(array, &entry); } static void emit_interfaces_added(struct generic_data *data) { DBusMessage *signal; DBusMessageIter iter, array; if (root == NULL || data == root) return; signal = dbus_message_new_signal(root->path, DBUS_INTERFACE_OBJECT_MANAGER, "InterfacesAdded"); if (signal == NULL) return; dbus_message_iter_init_append(signal, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &data->path); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array); g_slist_foreach(data->added, append_interface, &array); g_slist_free(data->added); data->added = NULL; dbus_message_iter_close_container(&iter, &array); g_dbus_send_message(data->conn, signal); } static struct interface_data *find_interface(GSList *interfaces, const char *name) { GSList *list; if (name == NULL) return NULL; for (list = interfaces; list; list = list->next) { struct interface_data *iface = list->data; if (!strcmp(name, iface->name)) return iface; } return NULL; } static gboolean g_dbus_args_have_signature(const GDBusArgInfo *args, DBusMessage *message) { const char *sig = dbus_message_get_signature(message); const char *p = NULL; for (; args && args->signature && *sig; args++) { p = args->signature; for (; *sig && *p; sig++, p++) { if (*p != *sig) return FALSE; } } if (*sig || (p && *p) || (args && args->signature)) return FALSE; return TRUE; } static gboolean remove_interface(struct generic_data *data, const char *name) { struct interface_data *iface; iface = find_interface(data->interfaces, name); if (iface == NULL) return FALSE; process_properties_from_interface(data, iface); data->interfaces = g_slist_remove(data->interfaces, iface); if (iface->destroy) { iface->destroy(iface->user_data); iface->user_data = NULL; } /* * Interface being removed was just added, on the same mainloop * iteration? Don't send any signal */ if (g_slist_find(data->added, iface)) { data->added = g_slist_remove(data->added, iface); g_free(iface->name); g_free(iface); return TRUE; } if (data->parent == NULL) { g_free(iface->name); g_free(iface); return TRUE; } data->removed = g_slist_prepend(data->removed, iface->name); g_free(iface); if (data->process_id > 0) return TRUE; data->process_id = g_idle_add(process_changes, data); return TRUE; } static struct generic_data *invalidate_parent_data(DBusConnection *conn, const char *child_path) { struct generic_data *data = NULL, *child = NULL, *parent = NULL; char *parent_path, *slash; parent_path = g_strdup(child_path); slash = strrchr(parent_path, '/'); if (slash == NULL) goto done; if (slash == parent_path && parent_path[1] != '\0') parent_path[1] = '\0'; else *slash = '\0'; if (!strlen(parent_path)) goto done; if (dbus_connection_get_object_path_data(conn, parent_path, (void *) &data) == FALSE) { goto done; } parent = invalidate_parent_data(conn, parent_path); if (data == NULL) { data = parent; if (data == NULL) goto done; } g_free(data->introspect); data->introspect = NULL; if (!dbus_connection_get_object_path_data(conn, child_path, (void *) &child)) goto done; if (child == NULL || g_slist_find(data->objects, child) != NULL) goto done; data->objects = g_slist_prepend(data->objects, child); child->parent = data; done: g_free(parent_path); return data; } static inline const GDBusPropertyTable *find_property(const GDBusPropertyTable *properties, const char *name) { const GDBusPropertyTable *p; for (p = properties; p && p->name; p++) { if (strcmp(name, p->name) != 0) continue; if (check_experimental(p->flags, G_DBUS_PROPERTY_FLAG_EXPERIMENTAL)) break; return p; } return NULL; } static DBusMessage *properties_get(DBusConnection *connection, DBusMessage *message, void *user_data) { struct generic_data *data = user_data; struct interface_data *iface; const GDBusPropertyTable *property; const char *interface, *name; DBusMessageIter iter, value; DBusMessage *reply; if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID)) return NULL; iface = find_interface(data->interfaces, interface); if (iface == NULL) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "No such interface '%s'", interface); property = find_property(iface->properties, name); if (property == NULL) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "No such property '%s'", name); if (property->exists != NULL && !property->exists(property, iface->user_data)) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "No such property '%s'", name); if (property->get == NULL) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "Property '%s' is not readable", name); reply = dbus_message_new_method_return(message); if (reply == NULL) return NULL; dbus_message_iter_init_append(reply, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, property->type, &value); if (!property->get(property, &value, iface->user_data)) { dbus_message_unref(reply); return NULL; } dbus_message_iter_close_container(&iter, &value); return reply; } static DBusMessage *properties_get_all(DBusConnection *connection, DBusMessage *message, void *user_data) { struct generic_data *data = user_data; struct interface_data *iface; const char *interface; DBusMessageIter iter; DBusMessage *reply; if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_INVALID)) return NULL; iface = find_interface(data->interfaces, interface); if (iface == NULL) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "No such interface '%s'", interface); reply = dbus_message_new_method_return(message); if (reply == NULL) return NULL; dbus_message_iter_init_append(reply, &iter); append_properties(iface, &iter); return reply; } static DBusMessage *properties_set(DBusConnection *connection, DBusMessage *message, void *user_data) { struct generic_data *data = user_data; DBusMessageIter iter, sub; struct interface_data *iface; const GDBusPropertyTable *property; const char *name, *interface; struct property_data *propdata; if (!dbus_message_iter_init(message, &iter)) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "No arguments given"); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "Invalid argument type: '%c'", dbus_message_iter_get_arg_type(&iter)); dbus_message_iter_get_basic(&iter, &interface); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "Invalid argument type: '%c'", dbus_message_iter_get_arg_type(&iter)); dbus_message_iter_get_basic(&iter, &name); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "Invalid argument type: '%c'", dbus_message_iter_get_arg_type(&iter)); dbus_message_iter_recurse(&iter, &sub); iface = find_interface(data->interfaces, interface); if (iface == NULL) return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS, "No such interface '%s'", interface); property = find_property(iface->properties, name); if (property == NULL) return g_dbus_create_error(message, DBUS_ERROR_UNKNOWN_PROPERTY, "No such property '%s'", name); if (property->set == NULL) return g_dbus_create_error(message, DBUS_ERROR_PROPERTY_READ_ONLY, "Property '%s' is not writable", name); if (property->exists != NULL && !property->exists(property, iface->user_data)) return g_dbus_create_error(message, DBUS_ERROR_UNKNOWN_PROPERTY, "No such property '%s'", name); propdata = g_new(struct property_data, 1); propdata->id = next_pending_property++; propdata->message = dbus_message_ref(message); propdata->conn = connection; pending_property_set = g_slist_prepend(pending_property_set, propdata); property->set(property, &sub, propdata->id, iface->user_data); return NULL; } static const GDBusMethodTable properties_methods[] = { { GDBUS_METHOD("Get", GDBUS_ARGS({ "interface", "s" }, { "name", "s" }), GDBUS_ARGS({ "value", "v" }), properties_get) }, { GDBUS_ASYNC_METHOD("Set", GDBUS_ARGS({ "interface", "s" }, { "name", "s" }, { "value", "v" }), NULL, properties_set) }, { GDBUS_METHOD("GetAll", GDBUS_ARGS({ "interface", "s" }), GDBUS_ARGS({ "properties", "a{sv}" }), properties_get_all) }, { } }; static const GDBusSignalTable properties_signals[] = { { GDBUS_SIGNAL("PropertiesChanged", GDBUS_ARGS({ "interface", "s" }, { "changed_properties", "a{sv}" }, { "invalidated_properties", "as"})) }, { } }; static void append_name(gpointer data, gpointer user_data) { char *name = data; DBusMessageIter *iter = user_data; dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &name); } static void emit_interfaces_removed(struct generic_data *data) { DBusMessage *signal; DBusMessageIter iter, array; if (root == NULL || data == root) return; signal = dbus_message_new_signal(root->path, DBUS_INTERFACE_OBJECT_MANAGER, "InterfacesRemoved"); if (signal == NULL) return; dbus_message_iter_init_append(signal, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &data->path); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &array); g_slist_foreach(data->removed, append_name, &array); g_slist_free_full(data->removed, g_free); data->removed = NULL; dbus_message_iter_close_container(&iter, &array); g_dbus_send_message(data->conn, signal); } static gboolean process_changes(gpointer user_data) { struct generic_data *data = user_data; data->process_id = 0; if (data->added != NULL) emit_interfaces_added(data); /* Flush pending properties */ if (data->pending_prop == TRUE) process_property_changes(data); if (data->removed != NULL) emit_interfaces_removed(data); return FALSE; } static void generic_unregister(DBusConnection *connection, void *user_data) { struct generic_data *data = user_data; struct generic_data *parent = data->parent; if (parent != NULL) parent->objects = g_slist_remove(parent->objects, data); if (data->process_id > 0) { g_source_remove(data->process_id); process_changes(data); } g_slist_foreach(data->objects, reset_parent, data->parent); g_slist_free(data->objects); dbus_connection_unref(data->conn); g_free(data->introspect); g_free(data->path); g_free(data); } static DBusHandlerResult generic_message(DBusConnection *connection, DBusMessage *message, void *user_data) { struct generic_data *data = user_data; struct interface_data *iface; const GDBusMethodTable *method; const char *interface; interface = dbus_message_get_interface(message); iface = find_interface(data->interfaces, interface); if (iface == NULL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; for (method = iface->methods; method && method->name && method->function; method++) { if (dbus_message_is_method_call(message, iface->name, method->name) == FALSE) continue; if (check_experimental(method->flags, G_DBUS_METHOD_FLAG_EXPERIMENTAL)) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (g_dbus_args_have_signature(method->in_args, message) == FALSE) continue; if (check_privilege(connection, message, method, iface->user_data) == TRUE) return DBUS_HANDLER_RESULT_HANDLED; return process_message(connection, message, method, iface->user_data); } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } static DBusObjectPathVTable generic_table = { .unregister_function = generic_unregister, .message_function = generic_message, }; static const GDBusMethodTable introspect_methods[] = { { GDBUS_METHOD("Introspect", NULL, GDBUS_ARGS({ "xml", "s" }), introspect) }, { } }; static void append_interfaces(struct generic_data *data, DBusMessageIter *iter) { DBusMessageIter array; dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array); g_slist_foreach(data->interfaces, append_interface, &array); dbus_message_iter_close_container(iter, &array); } static void append_object(gpointer data, gpointer user_data) { struct generic_data *child = data; DBusMessageIter *array = user_data; DBusMessageIter entry; dbus_message_iter_open_container(array, DBUS_TYPE_DICT_ENTRY, NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH, &child->path); append_interfaces(child, &entry); dbus_message_iter_close_container(array, &entry); g_slist_foreach(child->objects, append_object, user_data); } static DBusMessage *get_objects(DBusConnection *connection, DBusMessage *message, void *user_data) { struct generic_data *data = user_data; DBusMessage *reply; DBusMessageIter iter; DBusMessageIter array; reply = dbus_message_new_method_return(message); if (reply == NULL) return NULL; dbus_message_iter_init_append(reply, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array); g_slist_foreach(data->objects, append_object, &array); dbus_message_iter_close_container(&iter, &array); return reply; } static const GDBusMethodTable manager_methods[] = { { GDBUS_METHOD("GetManagedObjects", NULL, GDBUS_ARGS({ "objects", "a{oa{sa{sv}}}" }), get_objects) }, { } }; static const GDBusSignalTable manager_signals[] = { { GDBUS_SIGNAL("InterfacesAdded", GDBUS_ARGS({ "object", "o" }, { "interfaces", "a{sa{sv}}" })) }, { GDBUS_SIGNAL("InterfacesRemoved", GDBUS_ARGS({ "object", "o" }, { "interfaces", "as" })) }, { } }; static gboolean add_interface(struct generic_data *data, const char *name, const GDBusMethodTable *methods, const GDBusSignalTable *signals, const GDBusPropertyTable *properties, void *user_data, GDBusDestroyFunction destroy) { struct interface_data *iface; const GDBusMethodTable *method; const GDBusSignalTable *signal; const GDBusPropertyTable *property; for (method = methods; method && method->name; method++) { if (!check_experimental(method->flags, G_DBUS_METHOD_FLAG_EXPERIMENTAL)) goto done; } for (signal = signals; signal && signal->name; signal++) { if (!check_experimental(signal->flags, G_DBUS_SIGNAL_FLAG_EXPERIMENTAL)) goto done; } for (property = properties; property && property->name; property++) { if (!check_experimental(property->flags, G_DBUS_PROPERTY_FLAG_EXPERIMENTAL)) goto done; } /* Nothing to register */ return FALSE; done: iface = g_new0(struct interface_data, 1); iface->name = g_strdup(name); iface->methods = methods; iface->signals = signals; iface->properties = properties; iface->user_data = user_data; iface->destroy = destroy; data->interfaces = g_slist_append(data->interfaces, iface); if (data->parent == NULL) return TRUE; data->added = g_slist_append(data->added, iface); if (data->process_id > 0) return TRUE; data->process_id = g_idle_add(process_changes, data); return TRUE; } static struct generic_data *object_path_ref(DBusConnection *connection, const char *path) { struct generic_data *data; if (dbus_connection_get_object_path_data(connection, path, (void *) &data) == TRUE) { if (data != NULL) { data->refcount++; return data; } } data = g_new0(struct generic_data, 1); data->conn = dbus_connection_ref(connection); data->path = g_strdup(path); data->refcount = 1; data->introspect = g_strdup(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE ""); if (!dbus_connection_register_object_path(connection, path, &generic_table, data)) { g_free(data->introspect); g_free(data); return NULL; } invalidate_parent_data(connection, path); add_interface(data, DBUS_INTERFACE_INTROSPECTABLE, introspect_methods, NULL, NULL, data, NULL); return data; } static void object_path_unref(DBusConnection *connection, const char *path) { struct generic_data *data = NULL; if (dbus_connection_get_object_path_data(connection, path, (void *) &data) == FALSE) return; if (data == NULL) return; data->refcount--; if (data->refcount > 0) return; remove_interface(data, DBUS_INTERFACE_INTROSPECTABLE); remove_interface(data, DBUS_INTERFACE_PROPERTIES); invalidate_parent_data(data->conn, data->path); dbus_connection_unregister_object_path(data->conn, data->path); } static gboolean check_signal(DBusConnection *conn, const char *path, const char *interface, const char *name, const GDBusArgInfo **args) { struct generic_data *data = NULL; struct interface_data *iface; const GDBusSignalTable *signal; *args = NULL; if (!dbus_connection_get_object_path_data(conn, path, (void *) &data) || data == NULL) { error("dbus_connection_emit_signal: path %s isn't registered", path); return FALSE; } iface = find_interface(data->interfaces, interface); if (iface == NULL) { error("dbus_connection_emit_signal: %s does not implement %s", path, interface); return FALSE; } for (signal = iface->signals; signal && signal->name; signal++) { if (strcmp(signal->name, name) != 0) continue; if (signal->flags & G_DBUS_SIGNAL_FLAG_EXPERIMENTAL) { const char *env = g_getenv("GDBUS_EXPERIMENTAL"); if (g_strcmp0(env, "1") != 0) break; } *args = signal->args; return TRUE; } error("No signal named %s on interface %s", name, interface); return FALSE; } static dbus_bool_t emit_signal_valist(DBusConnection *conn, const char *path, const char *interface, const char *name, int first, va_list var_args) { DBusMessage *signal; dbus_bool_t ret; const GDBusArgInfo *args; if (!check_signal(conn, path, interface, name, &args)) return FALSE; signal = dbus_message_new_signal(path, interface, name); if (signal == NULL) { error("Unable to allocate new %s.%s signal", interface, name); return FALSE; } ret = dbus_message_append_args_valist(signal, first, var_args); if (!ret) goto fail; if (g_dbus_args_have_signature(args, signal) == FALSE) { error("%s.%s: got unexpected signature '%s'", interface, name, dbus_message_get_signature(signal)); ret = FALSE; goto fail; } ret = dbus_connection_send(conn, signal, NULL); fail: dbus_message_unref(signal); return ret; } gboolean g_dbus_register_interface(DBusConnection *connection, const char *path, const char *name, const GDBusMethodTable *methods, const GDBusSignalTable *signals, const GDBusPropertyTable *properties, void *user_data, GDBusDestroyFunction destroy) { struct generic_data *data; data = object_path_ref(connection, path); if (data == NULL) return FALSE; if (find_interface(data->interfaces, name)) { object_path_unref(connection, path); return FALSE; } if (!add_interface(data, name, methods, signals, properties, user_data, destroy)) { object_path_unref(connection, path); return FALSE; } if (properties != NULL && !find_interface(data->interfaces, DBUS_INTERFACE_PROPERTIES)) add_interface(data, DBUS_INTERFACE_PROPERTIES, properties_methods, properties_signals, NULL, data, NULL); g_free(data->introspect); data->introspect = NULL; return TRUE; } gboolean g_dbus_unregister_interface(DBusConnection *connection, const char *path, const char *name) { struct generic_data *data = NULL; if (path == NULL) return FALSE; if (dbus_connection_get_object_path_data(connection, path, (void *) &data) == FALSE) return FALSE; if (data == NULL) return FALSE; if (remove_interface(data, name) == FALSE) return FALSE; g_free(data->introspect); data->introspect = NULL; object_path_unref(connection, data->path); return TRUE; } gboolean g_dbus_register_security(const GDBusSecurityTable *security) { if (security_table != NULL) return FALSE; security_table = security; return TRUE; } gboolean g_dbus_unregister_security(const GDBusSecurityTable *security) { security_table = NULL; return TRUE; } DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, const char *format, va_list args) { char str[1024]; vsnprintf(str, sizeof(str), format, args); return dbus_message_new_error(message, name, str); } DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name, const char *format, ...) { va_list args; DBusMessage *reply; va_start(args, format); reply = g_dbus_create_error_valist(message, name, format, args); va_end(args); return reply; } DBusMessage *g_dbus_create_reply_valist(DBusMessage *message, int type, va_list args) { DBusMessage *reply; reply = dbus_message_new_method_return(message); if (reply == NULL) return NULL; if (dbus_message_append_args_valist(reply, type, args) == FALSE) { dbus_message_unref(reply); return NULL; } return reply; } DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...) { va_list args; DBusMessage *reply; va_start(args, type); reply = g_dbus_create_reply_valist(message, type, args); va_end(args); return reply; } gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message) { dbus_bool_t result; if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL) dbus_message_set_no_reply(message, TRUE); else if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL) { const char *path = dbus_message_get_path(message); const char *interface = dbus_message_get_interface(message); const char *name = dbus_message_get_member(message); const GDBusArgInfo *args; if (!check_signal(connection, path, interface, name, &args)) return FALSE; } result = dbus_connection_send(connection, message, NULL); dbus_message_unref(message); return result; } gboolean g_dbus_send_error_valist(DBusConnection *connection, DBusMessage *message, const char *name, const char *format, va_list args) { DBusMessage *error; char str[1024]; vsnprintf(str, sizeof(str), format, args); error = dbus_message_new_error(message, name, str); if (error == NULL) return FALSE; return g_dbus_send_message(connection, error); } gboolean g_dbus_send_error(DBusConnection *connection, DBusMessage *message, const char *name, const char *format, ...) { va_list args; gboolean result; va_start(args, format); result = g_dbus_send_error_valist(connection, message, name, format, args); va_end(args); return result; } gboolean g_dbus_send_reply_valist(DBusConnection *connection, DBusMessage *message, int type, va_list args) { DBusMessage *reply; reply = dbus_message_new_method_return(message); if (reply == NULL) return FALSE; if (dbus_message_append_args_valist(reply, type, args) == FALSE) { dbus_message_unref(reply); return FALSE; } return g_dbus_send_message(connection, reply); } gboolean g_dbus_send_reply(DBusConnection *connection, DBusMessage *message, int type, ...) { va_list args; gboolean result; va_start(args, type); result = g_dbus_send_reply_valist(connection, message, type, args); va_end(args); return result; } gboolean g_dbus_emit_signal(DBusConnection *connection, const char *path, const char *interface, const char *name, int type, ...) { va_list args; gboolean result; va_start(args, type); result = emit_signal_valist(connection, path, interface, name, type, args); va_end(args); return result; } gboolean g_dbus_emit_signal_valist(DBusConnection *connection, const char *path, const char *interface, const char *name, int type, va_list args) { return emit_signal_valist(connection, path, interface, name, type, args); } static void process_properties_from_interface(struct generic_data *data, struct interface_data *iface) { GSList *l; DBusMessage *signal; DBusMessageIter iter, dict, array; GSList *invalidated; if (iface->pending_prop == NULL) return; signal = dbus_message_new_signal(data->path, DBUS_INTERFACE_PROPERTIES, "PropertiesChanged"); if (signal == NULL) { error("Unable to allocate new " DBUS_INTERFACE_PROPERTIES ".PropertiesChanged signal"); return; } iface->pending_prop = g_slist_reverse(iface->pending_prop); dbus_message_iter_init_append(signal, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface->name); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); invalidated = NULL; for (l = iface->pending_prop; l != NULL; l = l->next) { GDBusPropertyTable *p = l->data; if (p->get == NULL) continue; if (p->exists != NULL && !p->exists(p, iface->user_data)) { invalidated = g_slist_prepend(invalidated, p); continue; } append_property(iface, p, &dict); } dbus_message_iter_close_container(&iter, &dict); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING_AS_STRING, &array); for (l = invalidated; l != NULL; l = g_slist_next(l)) { GDBusPropertyTable *p = l->data; dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING, &p->name); } g_slist_free(invalidated); dbus_message_iter_close_container(&iter, &array); g_dbus_send_message(data->conn, signal); g_slist_free(iface->pending_prop); iface->pending_prop = NULL; } static void process_property_changes(struct generic_data *data) { GSList *l; for (l = data->interfaces; l != NULL; l = l->next) { struct interface_data *iface = l->data; process_properties_from_interface(data, iface); } data->pending_prop = FALSE; } void g_dbus_emit_property_changed(DBusConnection *connection, const char *path, const char *interface, const char *name) { const GDBusPropertyTable *property; struct generic_data *data; struct interface_data *iface; if (!dbus_connection_get_object_path_data(connection, path, (void **) &data) || data == NULL) return; iface = find_interface(data->interfaces, interface); if (iface == NULL) return; property = find_property(iface->properties, name); if (property == NULL) { error("Could not find property %s in %p", name, iface->properties); return; } if (g_slist_find(iface->pending_prop, (void *) property) != NULL) return; data->pending_prop = TRUE; iface->pending_prop = g_slist_prepend(iface->pending_prop, (void *) property); if (!data->process_id) { data->process_id = g_idle_add(process_changes, data); return; } } gboolean g_dbus_get_properties(DBusConnection *connection, const char *path, const char *interface, DBusMessageIter *iter) { struct generic_data *data; struct interface_data *iface; if (!dbus_connection_get_object_path_data(connection, path, (void **) &data) || data == NULL) return FALSE; iface = find_interface(data->interfaces, interface); if (iface == NULL) return FALSE; append_properties(iface, iter); return TRUE; } gboolean g_dbus_attach_object_manager(DBusConnection *connection) { struct generic_data *data; data = object_path_ref(connection, "/"); if (data == NULL) return FALSE; add_interface(data, DBUS_INTERFACE_OBJECT_MANAGER, manager_methods, manager_signals, NULL, data, NULL); root = data; return TRUE; } gboolean g_dbus_detach_object_manager(DBusConnection *connection) { if (!g_dbus_unregister_interface(connection, "/", DBUS_INTERFACE_OBJECT_MANAGER)) return FALSE; root = NULL; return TRUE; } void g_dbus_set_flags(int flags) { global_flags = flags; } connman-ui-0_20150622+dfsg.orig/gdbus/mainloop.c0000644000175000017500000001775212541725135017657 0ustar nicknick/* * * D-Bus helper library * * Copyright (C) 2004-2011 Marcel Holtmann * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include "gdbus.h" #define DISPATCH_TIMEOUT 0 #define info(fmt...) #define error(fmt...) #define debug(fmt...) struct timeout_handler { guint id; DBusTimeout *timeout; }; struct watch_info { guint id; DBusWatch *watch; DBusConnection *conn; }; struct disconnect_data { GDBusWatchFunction function; void *user_data; }; static gboolean disconnected_signal(DBusConnection *conn, DBusMessage *msg, void *data) { struct disconnect_data *dc_data = data; error("Got disconnected from the system message bus"); dc_data->function(conn, dc_data->user_data); dbus_connection_unref(conn); return TRUE; } static gboolean message_dispatch(void *data) { DBusConnection *conn = data; dbus_connection_ref(conn); /* Dispatch messages */ while (dbus_connection_dispatch(conn) == DBUS_DISPATCH_DATA_REMAINS); dbus_connection_unref(conn); return FALSE; } static inline void queue_dispatch(DBusConnection *conn, DBusDispatchStatus status) { if (status == DBUS_DISPATCH_DATA_REMAINS) g_timeout_add(DISPATCH_TIMEOUT, message_dispatch, conn); } static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data) { struct watch_info *info = data; unsigned int flags = 0; DBusDispatchStatus status; DBusConnection *conn; conn = dbus_connection_ref(info->conn); if (cond & G_IO_IN) flags |= DBUS_WATCH_READABLE; if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE; if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP; if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR; dbus_watch_handle(info->watch, flags); status = dbus_connection_get_dispatch_status(conn); queue_dispatch(conn, status); dbus_connection_unref(conn); return TRUE; } static void watch_info_free(void *data) { struct watch_info *info = data; if (info->id > 0) { g_source_remove(info->id); info->id = 0; } dbus_connection_unref(info->conn); g_free(info); } static dbus_bool_t add_watch(DBusWatch *watch, void *data) { DBusConnection *conn = data; GIOCondition cond = G_IO_HUP | G_IO_ERR; GIOChannel *chan; struct watch_info *info; unsigned int flags; int fd; if (!dbus_watch_get_enabled(watch)) return TRUE; info = g_new0(struct watch_info, 1); fd = dbus_watch_get_unix_fd(watch); chan = g_io_channel_unix_new(fd); info->watch = watch; info->conn = dbus_connection_ref(conn); dbus_watch_set_data(watch, info, watch_info_free); flags = dbus_watch_get_flags(watch); if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN; if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT; info->id = g_io_add_watch(chan, cond, watch_func, info); g_io_channel_unref(chan); return TRUE; } static void remove_watch(DBusWatch *watch, void *data) { if (dbus_watch_get_enabled(watch)) return; /* will trigger watch_info_free() */ dbus_watch_set_data(watch, NULL, NULL); } static void watch_toggled(DBusWatch *watch, void *data) { /* Because we just exit on OOM, enable/disable is * no different from add/remove */ if (dbus_watch_get_enabled(watch)) add_watch(watch, data); else remove_watch(watch, data); } static gboolean timeout_handler_dispatch(gpointer data) { struct timeout_handler *handler = data; handler->id = 0; /* if not enabled should not be polled by the main loop */ if (!dbus_timeout_get_enabled(handler->timeout)) return FALSE; dbus_timeout_handle(handler->timeout); return FALSE; } static void timeout_handler_free(void *data) { struct timeout_handler *handler = data; if (handler->id > 0) { g_source_remove(handler->id); handler->id = 0; } g_free(handler); } static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data) { int interval = dbus_timeout_get_interval(timeout); struct timeout_handler *handler; if (!dbus_timeout_get_enabled(timeout)) return TRUE; handler = g_new0(struct timeout_handler, 1); handler->timeout = timeout; dbus_timeout_set_data(timeout, handler, timeout_handler_free); handler->id = g_timeout_add(interval, timeout_handler_dispatch, handler); return TRUE; } static void remove_timeout(DBusTimeout *timeout, void *data) { /* will trigger timeout_handler_free() */ dbus_timeout_set_data(timeout, NULL, NULL); } static void timeout_toggled(DBusTimeout *timeout, void *data) { if (dbus_timeout_get_enabled(timeout)) add_timeout(timeout, data); else remove_timeout(timeout, data); } static void dispatch_status(DBusConnection *conn, DBusDispatchStatus status, void *data) { if (!dbus_connection_get_is_connected(conn)) return; queue_dispatch(conn, status); } static inline void setup_dbus_with_main_loop(DBusConnection *conn) { dbus_connection_set_watch_functions(conn, add_watch, remove_watch, watch_toggled, conn, NULL); dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout, timeout_toggled, NULL, NULL); dbus_connection_set_dispatch_status_function(conn, dispatch_status, NULL, NULL); } static gboolean setup_bus(DBusConnection *conn, const char *name, DBusError *error) { gboolean result; DBusDispatchStatus status; if (name != NULL) { result = g_dbus_request_name(conn, name, error); if (error != NULL) { if (dbus_error_is_set(error) == TRUE) return FALSE; } if (result == FALSE) return FALSE; } setup_dbus_with_main_loop(conn); status = dbus_connection_get_dispatch_status(conn); queue_dispatch(conn, status); return TRUE; } DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name, DBusError *error) { DBusConnection *conn; conn = dbus_bus_get(type, error); if (error != NULL) { if (dbus_error_is_set(error) == TRUE) return NULL; } if (conn == NULL) return NULL; if (setup_bus(conn, name, error) == FALSE) { dbus_connection_unref(conn); return NULL; } return conn; } DBusConnection *g_dbus_setup_private(DBusBusType type, const char *name, DBusError *error) { DBusConnection *conn; conn = dbus_bus_get_private(type, error); if (error != NULL) { if (dbus_error_is_set(error) == TRUE) return NULL; } if (conn == NULL) return NULL; if (setup_bus(conn, name, error) == FALSE) { dbus_connection_unref(conn); return NULL; } return conn; } gboolean g_dbus_request_name(DBusConnection *connection, const char *name, DBusError *error) { int result; result = dbus_bus_request_name(connection, name, DBUS_NAME_FLAG_DO_NOT_QUEUE, error); if (error != NULL) { if (dbus_error_is_set(error) == TRUE) return FALSE; } if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) { if (error != NULL) dbus_set_error(error, name, "Name already in use"); return FALSE; } return TRUE; } gboolean g_dbus_set_disconnect_function(DBusConnection *connection, GDBusWatchFunction function, void *user_data, DBusFreeFunction destroy) { struct disconnect_data *dc_data; dc_data = g_new0(struct disconnect_data, 1); dc_data->function = function; dc_data->user_data = user_data; dbus_connection_set_exit_on_disconnect(connection, FALSE); if (g_dbus_add_signal_watch(connection, NULL, NULL, DBUS_INTERFACE_LOCAL, "Disconnected", disconnected_signal, dc_data, g_free) == 0) { error("Failed to add watch for D-Bus Disconnected signal"); g_free(dc_data); return FALSE; } return TRUE; } connman-ui-0_20150622+dfsg.orig/gdbus/client.c0000644000175000017500000007446112541725135017317 0ustar nicknick/* * * D-Bus helper library * * Copyright (C) 2004-2011 Marcel Holtmann * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include "gdbus.h" #define METHOD_CALL_TIMEOUT (300 * 1000) struct GDBusClient { gint ref_count; DBusConnection *dbus_conn; char *service_name; char *unique_name; char *base_path; GPtrArray *match_rules; DBusPendingCall *pending_call; GDBusWatchFunction connect_func; void *connect_data; GDBusWatchFunction disconn_func; void *disconn_data; GDBusMessageFunction signal_func; void *signal_data; GDBusProxyFunction proxy_added; GDBusProxyFunction proxy_removed; GDBusPropertyFunction property_changed; void *user_data; GList *proxy_list; }; struct GDBusProxy { gint ref_count; GDBusClient *client; char *obj_path; char *interface; GHashTable *prop_list; char *match_rule; GDBusPropertyFunction prop_func; void *prop_data; }; struct prop_entry { char *name; int type; DBusMessage *msg; }; static void modify_match_reply(DBusPendingCall *call, void *user_data) { DBusMessage *reply = dbus_pending_call_steal_reply(call); DBusError error; dbus_error_init(&error); if (dbus_set_error_from_message(&error, reply) == TRUE) dbus_error_free(&error); dbus_message_unref(reply); } static gboolean modify_match(DBusConnection *conn, const char *member, const char *rule) { DBusMessage *msg; DBusPendingCall *call; msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, member); if (msg == NULL) return FALSE; dbus_message_append_args(msg, DBUS_TYPE_STRING, &rule, DBUS_TYPE_INVALID); if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); return FALSE; } dbus_pending_call_set_notify(call, modify_match_reply, NULL, NULL); dbus_pending_call_unref(call); dbus_message_unref(msg); return TRUE; } static void iter_append_iter(DBusMessageIter *base, DBusMessageIter *iter) { int type; type = dbus_message_iter_get_arg_type(iter); if (dbus_type_is_basic(type)) { const void *value; dbus_message_iter_get_basic(iter, &value); dbus_message_iter_append_basic(base, type, &value); } else if (dbus_type_is_container(type)) { DBusMessageIter iter_sub, base_sub; char *sig; dbus_message_iter_recurse(iter, &iter_sub); switch (type) { case DBUS_TYPE_ARRAY: case DBUS_TYPE_VARIANT: sig = dbus_message_iter_get_signature(&iter_sub); break; default: sig = NULL; break; } dbus_message_iter_open_container(base, type, sig, &base_sub); if (sig != NULL) dbus_free(sig); while (dbus_message_iter_get_arg_type(&iter_sub) != DBUS_TYPE_INVALID) { iter_append_iter(&base_sub, &iter_sub); dbus_message_iter_next(&iter_sub); } dbus_message_iter_close_container(base, &base_sub); } } static void prop_entry_update(struct prop_entry *prop, DBusMessageIter *iter) { DBusMessage *msg; DBusMessageIter base; msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); if (msg == NULL) return; dbus_message_iter_init_append(msg, &base); iter_append_iter(&base, iter); if (prop->msg != NULL) dbus_message_unref(prop->msg); prop->msg = dbus_message_copy(msg); dbus_message_unref(msg); } static struct prop_entry *prop_entry_new(const char *name, DBusMessageIter *iter) { struct prop_entry *prop; prop = g_try_new0(struct prop_entry, 1); if (prop == NULL) return NULL; prop->name = g_strdup(name); prop->type = dbus_message_iter_get_arg_type(iter); prop_entry_update(prop, iter); return prop; } static void prop_entry_free(gpointer data) { struct prop_entry *prop = data; if (prop->msg != NULL) dbus_message_unref(prop->msg); g_free(prop->name); g_free(prop); } static void add_property(GDBusProxy *proxy, const char *name, DBusMessageIter *iter) { DBusMessageIter value; struct prop_entry *prop; if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT) return; dbus_message_iter_recurse(iter, &value); prop = g_hash_table_lookup(proxy->prop_list, name); if (prop != NULL) { GDBusClient *client = proxy->client; prop_entry_update(prop, &value); if (proxy->prop_func) proxy->prop_func(proxy, name, &value, proxy->prop_data); if (client == NULL) return; if (client->property_changed) client->property_changed(proxy, name, &value, client->user_data); return; } prop = prop_entry_new(name, &value); if (prop == NULL) return; g_hash_table_replace(proxy->prop_list, prop->name, prop); if (proxy->prop_func) proxy->prop_func(proxy, name, &value, proxy->prop_data); } static void update_properties(GDBusProxy *proxy, DBusMessageIter *iter) { DBusMessageIter dict; if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY) return; dbus_message_iter_recurse(iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry; const char *name; dbus_message_iter_recurse(&dict, &entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&entry, &name); dbus_message_iter_next(&entry); add_property(proxy, name, &entry); dbus_message_iter_next(&dict); } } static void get_all_properties_reply(DBusPendingCall *call, void *user_data) { GDBusProxy *proxy = user_data; GDBusClient *client = proxy->client; DBusMessage *reply = dbus_pending_call_steal_reply(call); DBusMessageIter iter; DBusError error; dbus_error_init(&error); if (dbus_set_error_from_message(&error, reply) == TRUE) { dbus_error_free(&error); goto done; } dbus_message_iter_init(reply, &iter); update_properties(proxy, &iter); done: if (g_list_find(client->proxy_list, proxy) == NULL) { if (client->proxy_added) client->proxy_added(proxy, client->user_data); client->proxy_list = g_list_append(client->proxy_list, proxy); } dbus_message_unref(reply); g_dbus_client_unref(client); } static void get_all_properties(GDBusProxy *proxy) { GDBusClient *client = proxy->client; const char *service_name = client->service_name; DBusMessage *msg; DBusPendingCall *call; msg = dbus_message_new_method_call(service_name, proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "GetAll"); if (msg == NULL) return; dbus_message_append_args(msg, DBUS_TYPE_STRING, &proxy->interface, DBUS_TYPE_INVALID); if (dbus_connection_send_with_reply(client->dbus_conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); return; } g_dbus_client_ref(client); dbus_pending_call_set_notify(call, get_all_properties_reply, proxy, NULL); dbus_pending_call_unref(call); dbus_message_unref(msg); } static GDBusProxy *proxy_lookup(GDBusClient *client, const char *path, const char *interface) { GList *list; for (list = g_list_first(client->proxy_list); list; list = g_list_next(list)) { GDBusProxy *proxy = list->data; if (g_str_equal(proxy->interface, interface) == TRUE && g_str_equal(proxy->obj_path, path) == TRUE) return proxy; } return NULL; } static GDBusProxy *proxy_new(GDBusClient *client, const char *path, const char *interface) { GDBusProxy *proxy; proxy = g_try_new0(GDBusProxy, 1); if (proxy == NULL) return NULL; proxy->client = client; proxy->obj_path = g_strdup(path); proxy->interface = g_strdup(interface); proxy->prop_list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, prop_entry_free); proxy->match_rule = g_strdup_printf("type='signal'," "sender='%s',path='%s',interface='%s'," "member='PropertiesChanged',arg0='%s'", client->service_name, proxy->obj_path, DBUS_INTERFACE_PROPERTIES, proxy->interface); modify_match(client->dbus_conn, "AddMatch", proxy->match_rule); return g_dbus_proxy_ref(proxy); } static void proxy_free(gpointer data) { GDBusProxy *proxy = data; if (proxy->client) { GDBusClient *client = proxy->client; if (client->proxy_removed) client->proxy_removed(proxy, client->user_data); modify_match(client->dbus_conn, "RemoveMatch", proxy->match_rule); g_free(proxy->match_rule); proxy->match_rule = NULL; g_hash_table_remove_all(proxy->prop_list); proxy->client = NULL; } g_dbus_proxy_unref(proxy); } static void proxy_remove(GDBusClient *client, const char *path, const char *interface) { GList *list; for (list = g_list_first(client->proxy_list); list; list = g_list_next(list)) { GDBusProxy *proxy = list->data; if (g_str_equal(proxy->interface, interface) == TRUE && g_str_equal(proxy->obj_path, path) == TRUE) { client->proxy_list = g_list_delete_link(client->proxy_list, list); proxy_free(proxy); break; } } } GDBusProxy *g_dbus_proxy_new(GDBusClient *client, const char *path, const char *interface) { GDBusProxy *proxy; if (client == NULL) return NULL; proxy = proxy_lookup(client, path, interface); if (proxy) return g_dbus_proxy_ref(proxy); proxy = proxy_new(client, path, interface); if (proxy == NULL) return NULL; get_all_properties(proxy); return g_dbus_proxy_ref(proxy); } GDBusProxy *g_dbus_proxy_ref(GDBusProxy *proxy) { if (proxy == NULL) return NULL; g_atomic_int_inc(&proxy->ref_count); return proxy; } void g_dbus_proxy_unref(GDBusProxy *proxy) { if (proxy == NULL) return; if (g_atomic_int_dec_and_test(&proxy->ref_count) == FALSE) return; g_hash_table_destroy(proxy->prop_list); g_free(proxy->obj_path); g_free(proxy->interface); g_free(proxy); } const char *g_dbus_proxy_get_path(GDBusProxy *proxy) { if (proxy == NULL) return NULL; return proxy->obj_path; } const char *g_dbus_proxy_get_interface(GDBusProxy *proxy) { if (proxy == NULL) return NULL; return proxy->interface; } gboolean g_dbus_proxy_get_property(GDBusProxy *proxy, const char *name, DBusMessageIter *iter) { struct prop_entry *prop; if (proxy == NULL || name == NULL) return FALSE; prop = g_hash_table_lookup(proxy->prop_list, name); if (prop == NULL) return FALSE; if (prop->msg == NULL) return FALSE; if (dbus_message_iter_init(prop->msg, iter) == FALSE) return FALSE; return TRUE; } struct refresh_property_data { GDBusProxy *proxy; char *name; }; static void refresh_property_free(gpointer user_data) { struct refresh_property_data *data = user_data; g_free(data->name); g_free(data); } static void refresh_property_reply(DBusPendingCall *call, void *user_data) { struct refresh_property_data *data = user_data; DBusMessage *reply = dbus_pending_call_steal_reply(call); DBusError error; dbus_error_init(&error); if (dbus_set_error_from_message(&error, reply) == FALSE) { DBusMessageIter iter; dbus_message_iter_init(reply, &iter); add_property(data->proxy, data->name, &iter); } else dbus_error_free(&error); dbus_message_unref(reply); } gboolean g_dbus_proxy_refresh_property(GDBusProxy *proxy, const char *name) { struct refresh_property_data *data; GDBusClient *client; DBusMessage *msg; DBusMessageIter iter; DBusPendingCall *call; if (proxy == NULL || name == NULL) return FALSE; client = proxy->client; if (client == NULL) return FALSE; data = g_try_new0(struct refresh_property_data, 1); if (data == NULL) return FALSE; data->proxy = proxy; data->name = g_strdup(name); msg = dbus_message_new_method_call(client->service_name, proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "Get"); if (msg == NULL) { refresh_property_free(data); return FALSE; } dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &proxy->interface); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); if (dbus_connection_send_with_reply(client->dbus_conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); refresh_property_free(data); return FALSE; } dbus_pending_call_set_notify(call, refresh_property_reply, data, refresh_property_free); dbus_pending_call_unref(call); dbus_message_unref(msg); return TRUE; } struct set_property_data { GDBusResultFunction function; void *user_data; GDBusDestroyFunction destroy; }; static void set_property_reply(DBusPendingCall *call, void *user_data) { struct set_property_data *data = user_data; DBusMessage *reply = dbus_pending_call_steal_reply(call); DBusError error; dbus_error_init(&error); dbus_set_error_from_message(&error, reply); if (data->function) data->function(&error, data->user_data); if (data->destroy) data->destroy(data->user_data); dbus_error_free(&error); dbus_message_unref(reply); } gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy, const char *name, int type, const void *value, GDBusResultFunction function, void *user_data, GDBusDestroyFunction destroy) { struct set_property_data *data; GDBusClient *client; DBusMessage *msg; DBusMessageIter iter, variant; DBusPendingCall *call; char type_as_str[2]; if (proxy == NULL || name == NULL || value == NULL) return FALSE; if (dbus_type_is_basic(type) == FALSE) return FALSE; client = proxy->client; if (client == NULL) return FALSE; data = g_try_new0(struct set_property_data, 1); if (data == NULL) return FALSE; data->function = function; data->user_data = user_data; data->destroy = destroy; msg = dbus_message_new_method_call(client->service_name, proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "Set"); if (msg == NULL) { g_free(data); return FALSE; } type_as_str[0] = (char) type; type_as_str[1] = '\0'; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &proxy->interface); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, type_as_str, &variant); dbus_message_iter_append_basic(&variant, type, value); dbus_message_iter_close_container(&iter, &variant); if (dbus_connection_send_with_reply(client->dbus_conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); g_free(data); return FALSE; } dbus_pending_call_set_notify(call, set_property_reply, data, g_free); dbus_pending_call_unref(call); dbus_message_unref(msg); return TRUE; } struct method_call_data { GDBusReturnFunction function; void *user_data; GDBusDestroyFunction destroy; }; static void method_call_reply(DBusPendingCall *call, void *user_data) { struct method_call_data *data = user_data; DBusMessage *reply = dbus_pending_call_steal_reply(call); if (data->function) data->function(reply, data->user_data); if (data->destroy) data->destroy(data->user_data); dbus_message_unref(reply); } gboolean g_dbus_proxy_method_call(GDBusProxy *proxy, const char *method, GDBusSetupFunction setup, GDBusReturnFunction function, void *user_data, GDBusDestroyFunction destroy) { struct method_call_data *data; GDBusClient *client; DBusMessage *msg; DBusPendingCall *call; if (proxy == NULL || method == NULL) return FALSE; client = proxy->client; if (client == NULL) return FALSE; data = g_try_new0(struct method_call_data, 1); if (data == NULL) return FALSE; data->function = function; data->user_data = user_data; data->destroy = destroy; msg = dbus_message_new_method_call(client->service_name, proxy->obj_path, proxy->interface, method); if (msg == NULL) { g_free(data); return FALSE; } if (setup) { DBusMessageIter iter; dbus_message_iter_init_append(msg, &iter); setup(&iter, data->user_data); } if (dbus_connection_send_with_reply(client->dbus_conn, msg, &call, METHOD_CALL_TIMEOUT) == FALSE) { dbus_message_unref(msg); g_free(data); return FALSE; } dbus_pending_call_set_notify(call, method_call_reply, data, g_free); dbus_pending_call_unref(call); dbus_message_unref(msg); return TRUE; } gboolean g_dbus_proxy_set_property_watch(GDBusProxy *proxy, GDBusPropertyFunction function, void *user_data) { if (proxy == NULL) return FALSE; proxy->prop_func = function; proxy->prop_data = user_data; return TRUE; } static void refresh_properties(GDBusClient *client) { GList *list; for (list = g_list_first(client->proxy_list); list; list = g_list_next(list)) { GDBusProxy *proxy = list->data; get_all_properties(proxy); } } static void properties_changed(GDBusClient *client, const char *path, DBusMessage *msg) { GDBusProxy *proxy = NULL; DBusMessageIter iter, entry; const char *interface; GList *list; if (dbus_message_iter_init(msg, &iter) == FALSE) return; if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return; dbus_message_iter_get_basic(&iter, &interface); dbus_message_iter_next(&iter); for (list = g_list_first(client->proxy_list); list; list = g_list_next(list)) { GDBusProxy *data = list->data; if (g_str_equal(data->interface, interface) == TRUE && g_str_equal(data->obj_path, path) == TRUE) { proxy = data; break; } } if (proxy == NULL) return; update_properties(proxy, &iter); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) return; dbus_message_iter_recurse(&iter, &entry); while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) { const char *name; dbus_message_iter_get_basic(&entry, &name); g_hash_table_remove(proxy->prop_list, name); if (proxy->prop_func) proxy->prop_func(proxy, name, NULL, proxy->prop_data); if (client->property_changed) client->property_changed(proxy, name, NULL, client->user_data); dbus_message_iter_next(&entry); } } static void parse_properties(GDBusClient *client, const char *path, const char *interface, DBusMessageIter *iter) { GDBusProxy *proxy; if (g_str_equal(interface, DBUS_INTERFACE_INTROSPECTABLE) == TRUE) return; if (g_str_equal(interface, DBUS_INTERFACE_PROPERTIES) == TRUE) return; proxy = proxy_lookup(client, path, interface); if (proxy) { update_properties(proxy, iter); return; } proxy = proxy_new(client, path, interface); if (proxy == NULL) return; update_properties(proxy, iter); if (client->proxy_added) client->proxy_added(proxy, client->user_data); client->proxy_list = g_list_append(client->proxy_list, proxy); } static void parse_interfaces(GDBusClient *client, const char *path, DBusMessageIter *iter) { DBusMessageIter dict; if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY) return; dbus_message_iter_recurse(iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry; const char *interface; dbus_message_iter_recurse(&dict, &entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&entry, &interface); dbus_message_iter_next(&entry); parse_properties(client, path, interface, &entry); dbus_message_iter_next(&dict); } } static void interfaces_added(GDBusClient *client, DBusMessage *msg) { DBusMessageIter iter; const char *path; if (dbus_message_iter_init(msg, &iter) == FALSE) return; if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) return; dbus_message_iter_get_basic(&iter, &path); dbus_message_iter_next(&iter); g_dbus_client_ref(client); parse_interfaces(client, path, &iter); g_dbus_client_unref(client); } static void interfaces_removed(GDBusClient *client, DBusMessage *msg) { DBusMessageIter iter, entry; const char *path; if (dbus_message_iter_init(msg, &iter) == FALSE) return; if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) return; dbus_message_iter_get_basic(&iter, &path); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) return; dbus_message_iter_recurse(&iter, &entry); g_dbus_client_ref(client); while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) { const char *interface; dbus_message_iter_get_basic(&entry, &interface); proxy_remove(client, path, interface); dbus_message_iter_next(&entry); } g_dbus_client_unref(client); } static void parse_managed_objects(GDBusClient *client, DBusMessage *msg) { DBusMessageIter iter, dict; if (dbus_message_iter_init(msg, &iter) == FALSE) return; if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) return; dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry; const char *path; dbus_message_iter_recurse(&dict, &entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_OBJECT_PATH) break; dbus_message_iter_get_basic(&entry, &path); dbus_message_iter_next(&entry); parse_interfaces(client, path, &entry); dbus_message_iter_next(&dict); } } static void get_managed_objects_reply(DBusPendingCall *call, void *user_data) { GDBusClient *client = user_data; DBusMessage *reply = dbus_pending_call_steal_reply(call); DBusError error; dbus_error_init(&error); if (dbus_set_error_from_message(&error, reply) == TRUE) { dbus_error_free(&error); goto done; } parse_managed_objects(client, reply); done: dbus_message_unref(reply); g_dbus_client_unref(client); } static void get_managed_objects(GDBusClient *client) { DBusMessage *msg; DBusPendingCall *call; if (!client->proxy_added && !client->proxy_removed) { refresh_properties(client); return; } msg = dbus_message_new_method_call(client->service_name, "/", DBUS_INTERFACE_DBUS ".ObjectManager", "GetManagedObjects"); if (msg == NULL) return; dbus_message_append_args(msg, DBUS_TYPE_INVALID); if (dbus_connection_send_with_reply(client->dbus_conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); return; } g_dbus_client_ref(client); dbus_pending_call_set_notify(call, get_managed_objects_reply, client, NULL); dbus_pending_call_unref(call); dbus_message_unref(msg); } static void get_name_owner_reply(DBusPendingCall *call, void *user_data) { GDBusClient *client = user_data; DBusMessage *reply = dbus_pending_call_steal_reply(call); DBusError error; const char *name; dbus_error_init(&error); if (dbus_set_error_from_message(&error, reply) == TRUE) { dbus_error_free(&error); goto done; } if (dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID) == FALSE) goto done; if (client->unique_name == NULL) { client->unique_name = g_strdup(name); if (client->connect_func) client->connect_func(client->dbus_conn, client->connect_data); get_managed_objects(client); } done: dbus_message_unref(reply); dbus_pending_call_unref(client->pending_call); client->pending_call = NULL; } static void get_name_owner(GDBusClient *client, const char *name) { DBusMessage *msg; msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner"); if (msg == NULL) return; dbus_message_append_args(msg, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID); if (dbus_connection_send_with_reply(client->dbus_conn, msg, &client->pending_call, -1) == FALSE) { dbus_message_unref(msg); return; } dbus_pending_call_set_notify(client->pending_call, get_name_owner_reply, client, NULL); dbus_message_unref(msg); } static DBusHandlerResult message_filter(DBusConnection *connection, DBusMessage *message, void *user_data) { GDBusClient *client = user_data; const char *sender; if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; sender = dbus_message_get_sender(message); if (g_str_equal(sender, DBUS_SERVICE_DBUS) == TRUE) { const char *interface, *member; const char *name, *old, *new; interface = dbus_message_get_interface(message); if (g_str_equal(interface, DBUS_INTERFACE_DBUS) == FALSE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; member = dbus_message_get_member(message); if (g_str_equal(member, "NameOwnerChanged") == FALSE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old, DBUS_TYPE_STRING, &new, DBUS_TYPE_INVALID) == FALSE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (g_str_equal(name, client->service_name) == FALSE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (*new == '\0' && client->unique_name != NULL && g_str_equal(old, client->unique_name) == TRUE) { if (client->disconn_func) client->disconn_func(client->dbus_conn, client->disconn_data); g_free(client->unique_name); client->unique_name = NULL; } else if (*old == '\0' && client->unique_name == NULL) { client->unique_name = g_strdup(new); if (client->connect_func) client->connect_func(client->dbus_conn, client->connect_data); get_managed_objects(client); } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (client->unique_name == NULL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (g_str_equal(sender, client->unique_name) == TRUE) { const char *path, *interface, *member; path = dbus_message_get_path(message); interface = dbus_message_get_interface(message); member = dbus_message_get_member(message); if (g_str_equal(path, "/") == TRUE) { if (g_str_equal(interface, DBUS_INTERFACE_DBUS ".ObjectManager") == FALSE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (g_str_equal(member, "InterfacesAdded") == TRUE) { interfaces_added(client, message); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (g_str_equal(member, "InterfacesRemoved") == TRUE) { interfaces_removed(client, message); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (g_str_has_prefix(path, client->base_path) == FALSE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (g_str_equal(interface, DBUS_INTERFACE_PROPERTIES) == TRUE) { if (g_str_equal(member, "PropertiesChanged") == TRUE) properties_changed(client, path, message); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (client->signal_func) client->signal_func(client->dbus_conn, message, client->signal_data); } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } GDBusClient *g_dbus_client_new(DBusConnection *connection, const char *service, const char *path) { GDBusClient *client; unsigned int i; if (connection == NULL) return NULL; client = g_try_new0(GDBusClient, 1); if (client == NULL) return NULL; if (dbus_connection_add_filter(connection, message_filter, client, NULL) == FALSE) { g_free(client); return NULL; } client->dbus_conn = dbus_connection_ref(connection); client->service_name = g_strdup(service); client->base_path = g_strdup(path); get_name_owner(client, client->service_name); client->match_rules = g_ptr_array_sized_new(4); g_ptr_array_set_free_func(client->match_rules, g_free); g_ptr_array_add(client->match_rules, g_strdup_printf("type='signal'," "sender='%s',path='%s',interface='%s'," "member='NameOwnerChanged',arg0='%s'", DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, client->service_name)); g_ptr_array_add(client->match_rules, g_strdup_printf("type='signal'," "sender='%s'," "path='/',interface='%s.ObjectManager'," "member='InterfacesAdded'", client->service_name, DBUS_INTERFACE_DBUS)); g_ptr_array_add(client->match_rules, g_strdup_printf("type='signal'," "sender='%s'," "path='/',interface='%s.ObjectManager'," "member='InterfacesRemoved'", client->service_name, DBUS_INTERFACE_DBUS)); g_ptr_array_add(client->match_rules, g_strdup_printf("type='signal'," "sender='%s',path_namespace='%s'", client->service_name, client->base_path)); for (i = 0; i < client->match_rules->len; i++) { modify_match(client->dbus_conn, "AddMatch", g_ptr_array_index(client->match_rules, i)); } return g_dbus_client_ref(client); } GDBusClient *g_dbus_client_ref(GDBusClient *client) { if (client == NULL) return NULL; g_atomic_int_inc(&client->ref_count); return client; } void g_dbus_client_unref(GDBusClient *client) { unsigned int i; if (client == NULL) return; if (g_atomic_int_dec_and_test(&client->ref_count) == FALSE) return; if (client->pending_call != NULL) { dbus_pending_call_cancel(client->pending_call); dbus_pending_call_unref(client->pending_call); } for (i = 0; i < client->match_rules->len; i++) { modify_match(client->dbus_conn, "RemoveMatch", g_ptr_array_index(client->match_rules, i)); } g_ptr_array_free(client->match_rules, TRUE); dbus_connection_remove_filter(client->dbus_conn, message_filter, client); g_list_free_full(client->proxy_list, proxy_free); if (client->disconn_func) client->disconn_func(client->dbus_conn, client->disconn_data); dbus_connection_unref(client->dbus_conn); g_free(client->service_name); g_free(client->unique_name); g_free(client->base_path); g_free(client); } gboolean g_dbus_client_set_connect_watch(GDBusClient *client, GDBusWatchFunction function, void *user_data) { if (client == NULL) return FALSE; client->connect_func = function; client->connect_data = user_data; return TRUE; } gboolean g_dbus_client_set_disconnect_watch(GDBusClient *client, GDBusWatchFunction function, void *user_data) { if (client == NULL) return FALSE; client->disconn_func = function; client->disconn_data = user_data; return TRUE; } gboolean g_dbus_client_set_signal_watch(GDBusClient *client, GDBusMessageFunction function, void *user_data) { if (client == NULL) return FALSE; client->signal_func = function; client->signal_data = user_data; return TRUE; } gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client, GDBusProxyFunction proxy_added, GDBusProxyFunction proxy_removed, GDBusPropertyFunction property_changed, void *user_data) { if (client == NULL) return FALSE; client->proxy_added = proxy_added; client->proxy_removed = proxy_removed; client->property_changed = property_changed; client->user_data = user_data; get_managed_objects(client); return TRUE; } connman-ui-0_20150622+dfsg.orig/gdbus/watch.c0000644000175000017500000004450012541725135017136 0ustar nicknick/* * * D-Bus helper library * * Copyright (C) 2004-2011 Marcel Holtmann * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include "gdbus.h" #define info(fmt...) #define error(fmt...) #define debug(fmt...) static DBusHandlerResult message_filter(DBusConnection *connection, DBusMessage *message, void *user_data); static guint listener_id = 0; static GSList *listeners = NULL; struct service_data { DBusConnection *conn; DBusPendingCall *call; char *name; const char *owner; guint id; struct filter_callback *callback; }; struct filter_callback { GDBusWatchFunction conn_func; GDBusWatchFunction disc_func; GDBusSignalFunction signal_func; GDBusDestroyFunction destroy_func; struct service_data *data; void *user_data; guint id; }; struct filter_data { DBusConnection *connection; DBusHandleMessageFunction handle_func; char *name; char *owner; char *path; char *interface; char *member; char *argument; GSList *callbacks; GSList *processed; guint name_watch; gboolean lock; gboolean registered; }; static struct filter_data *filter_data_find_match(DBusConnection *connection, const char *name, const char *owner, const char *path, const char *interface, const char *member, const char *argument) { GSList *current; for (current = listeners; current != NULL; current = current->next) { struct filter_data *data = current->data; if (connection != data->connection) continue; if (g_strcmp0(name, data->name) != 0) continue; if (g_strcmp0(owner, data->owner) != 0) continue; if (g_strcmp0(path, data->path) != 0) continue; if (g_strcmp0(interface, data->interface) != 0) continue; if (g_strcmp0(member, data->member) != 0) continue; if (g_strcmp0(argument, data->argument) != 0) continue; return data; } return NULL; } static struct filter_data *filter_data_find(DBusConnection *connection) { GSList *current; for (current = listeners; current != NULL; current = current->next) { struct filter_data *data = current->data; if (connection != data->connection) continue; return data; } return NULL; } static void format_rule(struct filter_data *data, char *rule, size_t size) { const char *sender; int offset; offset = snprintf(rule, size, "type='signal'"); sender = data->name ? : data->owner; if (sender) offset += snprintf(rule + offset, size - offset, ",sender='%s'", sender); if (data->path) offset += snprintf(rule + offset, size - offset, ",path='%s'", data->path); if (data->interface) offset += snprintf(rule + offset, size - offset, ",interface='%s'", data->interface); if (data->member) offset += snprintf(rule + offset, size - offset, ",member='%s'", data->member); if (data->argument) snprintf(rule + offset, size - offset, ",arg0='%s'", data->argument); } static gboolean add_match(struct filter_data *data, DBusHandleMessageFunction filter) { DBusError err; char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH]; format_rule(data, rule, sizeof(rule)); dbus_error_init(&err); dbus_bus_add_match(data->connection, rule, &err); if (dbus_error_is_set(&err)) { error("Adding match rule \"%s\" failed: %s", rule, err.message); dbus_error_free(&err); return FALSE; } data->handle_func = filter; data->registered = TRUE; return TRUE; } static gboolean remove_match(struct filter_data *data) { DBusError err; char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH]; format_rule(data, rule, sizeof(rule)); dbus_error_init(&err); dbus_bus_remove_match(data->connection, rule, &err); if (dbus_error_is_set(&err)) { error("Removing owner match rule for %s failed: %s", rule, err.message); dbus_error_free(&err); return FALSE; } return TRUE; } static struct filter_data *filter_data_get(DBusConnection *connection, DBusHandleMessageFunction filter, const char *sender, const char *path, const char *interface, const char *member, const char *argument) { struct filter_data *data; const char *name = NULL, *owner = NULL; if (filter_data_find(connection) == NULL) { if (!dbus_connection_add_filter(connection, message_filter, NULL, NULL)) { error("dbus_connection_add_filter() failed"); return NULL; } } if (sender == NULL) goto proceed; if (sender[0] == ':') owner = sender; else name = sender; proceed: data = filter_data_find_match(connection, name, owner, path, interface, member, argument); if (data) return data; data = g_new0(struct filter_data, 1); data->connection = dbus_connection_ref(connection); data->name = g_strdup(name); data->owner = g_strdup(owner); data->path = g_strdup(path); data->interface = g_strdup(interface); data->member = g_strdup(member); data->argument = g_strdup(argument); if (!add_match(data, filter)) { g_free(data); return NULL; } listeners = g_slist_append(listeners, data); return data; } static struct filter_callback *filter_data_find_callback( struct filter_data *data, guint id) { GSList *l; for (l = data->callbacks; l; l = l->next) { struct filter_callback *cb = l->data; if (cb->id == id) return cb; } for (l = data->processed; l; l = l->next) { struct filter_callback *cb = l->data; if (cb->id == id) return cb; } return NULL; } static void filter_data_free(struct filter_data *data) { GSList *l; for (l = data->callbacks; l != NULL; l = l->next) g_free(l->data); g_slist_free(data->callbacks); g_dbus_remove_watch(data->connection, data->name_watch); g_free(data->name); g_free(data->owner); g_free(data->path); g_free(data->interface); g_free(data->member); g_free(data->argument); dbus_connection_unref(data->connection); g_free(data); } static void filter_data_call_and_free(struct filter_data *data) { GSList *l; for (l = data->callbacks; l != NULL; l = l->next) { struct filter_callback *cb = l->data; if (cb->disc_func) cb->disc_func(data->connection, cb->user_data); if (cb->destroy_func) cb->destroy_func(cb->user_data); g_free(cb); } g_slist_free(data->callbacks); data->callbacks = NULL; filter_data_free(data); } static struct filter_callback *filter_data_add_callback( struct filter_data *data, GDBusWatchFunction connect, GDBusWatchFunction disconnect, GDBusSignalFunction signal, GDBusDestroyFunction destroy, void *user_data) { struct filter_callback *cb = NULL; cb = g_new0(struct filter_callback, 1); cb->conn_func = connect; cb->disc_func = disconnect; cb->signal_func = signal; cb->destroy_func = destroy; cb->user_data = user_data; cb->id = ++listener_id; if (data->lock) data->processed = g_slist_append(data->processed, cb); else data->callbacks = g_slist_append(data->callbacks, cb); return cb; } static void service_data_free(struct service_data *data) { struct filter_callback *callback = data->callback; dbus_connection_unref(data->conn); if (data->call) dbus_pending_call_unref(data->call); if (data->id) g_source_remove(data->id); g_free(data->name); g_free(data); callback->data = NULL; } static gboolean filter_data_remove_callback(struct filter_data *data, struct filter_callback *cb) { DBusConnection *connection; data->callbacks = g_slist_remove(data->callbacks, cb); data->processed = g_slist_remove(data->processed, cb); /* Cancel pending operations */ if (cb->data) { if (cb->data->call) dbus_pending_call_cancel(cb->data->call); service_data_free(cb->data); } if (cb->destroy_func) cb->destroy_func(cb->user_data); g_free(cb); /* Don't remove the filter if other callbacks exist or data is lock * processing callbacks */ if (data->callbacks || data->lock) return TRUE; if (data->registered && !remove_match(data)) return FALSE; connection = dbus_connection_ref(data->connection); listeners = g_slist_remove(listeners, data); /* Remove filter if there are no listeners left for the connection */ if (filter_data_find(connection) == NULL) dbus_connection_remove_filter(connection, message_filter, NULL); filter_data_free(data); dbus_connection_unref(connection); return TRUE; } static DBusHandlerResult signal_filter(DBusConnection *connection, DBusMessage *message, void *user_data) { struct filter_data *data = user_data; struct filter_callback *cb; while (data->callbacks) { cb = data->callbacks->data; if (cb->signal_func && !cb->signal_func(connection, message, cb->user_data)) { filter_data_remove_callback(data, cb); continue; } /* Check if the watch was removed/freed by the callback * function */ if (!g_slist_find(data->callbacks, cb)) continue; data->callbacks = g_slist_remove(data->callbacks, cb); data->processed = g_slist_append(data->processed, cb); } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } static void update_name_cache(const char *name, const char *owner) { GSList *l; for (l = listeners; l != NULL; l = l->next) { struct filter_data *data = l->data; if (g_strcmp0(data->name, name) != 0) continue; g_free(data->owner); data->owner = g_strdup(owner); } } static const char *check_name_cache(const char *name) { GSList *l; for (l = listeners; l != NULL; l = l->next) { struct filter_data *data = l->data; if (g_strcmp0(data->name, name) != 0) continue; return data->owner; } return NULL; } static DBusHandlerResult service_filter(DBusConnection *connection, DBusMessage *message, void *user_data) { struct filter_data *data = user_data; struct filter_callback *cb; char *name, *old, *new; if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &old, DBUS_TYPE_STRING, &new, DBUS_TYPE_INVALID)) { error("Invalid arguments for NameOwnerChanged signal"); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } update_name_cache(name, new); while (data->callbacks) { cb = data->callbacks->data; if (*new == '\0') { if (cb->disc_func) cb->disc_func(connection, cb->user_data); } else { if (cb->conn_func) cb->conn_func(connection, cb->user_data); } /* Check if the watch was removed/freed by the callback * function */ if (!g_slist_find(data->callbacks, cb)) continue; /* Only auto remove if it is a bus name watch */ if (data->argument[0] == ':' && (cb->conn_func == NULL || cb->disc_func == NULL)) { filter_data_remove_callback(data, cb); continue; } data->callbacks = g_slist_remove(data->callbacks, cb); data->processed = g_slist_append(data->processed, cb); } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } static DBusHandlerResult message_filter(DBusConnection *connection, DBusMessage *message, void *user_data) { struct filter_data *data; const char *sender, *path, *iface, *member, *arg = NULL; GSList *current, *delete_listener = NULL; /* Only filter signals */ if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; sender = dbus_message_get_sender(message); path = dbus_message_get_path(message); iface = dbus_message_get_interface(message); member = dbus_message_get_member(message); dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID); /* Sender is always the owner */ for (current = listeners; current != NULL; current = current->next) { data = current->data; if (connection != data->connection) continue; if (data->owner && g_str_equal(sender, data->owner) == FALSE) continue; if (data->path && g_str_equal(path, data->path) == FALSE) continue; if (data->interface && g_str_equal(iface, data->interface) == FALSE) continue; if (data->member && g_str_equal(member, data->member) == FALSE) continue; if (data->argument && g_str_equal(arg, data->argument) == FALSE) continue; if (data->handle_func) { data->lock = TRUE; data->handle_func(connection, message, data); data->callbacks = data->processed; data->processed = NULL; data->lock = FALSE; } if (!data->callbacks) delete_listener = g_slist_prepend(delete_listener, current); } for (current = delete_listener; current != NULL; current = delete_listener->next) { GSList *l = current->data; data = l->data; /* Has any other callback added callbacks back to this data? */ if (data->callbacks != NULL) continue; remove_match(data); listeners = g_slist_delete_link(listeners, l); filter_data_free(data); } g_slist_free(delete_listener); /* Remove filter if there are no listeners left for the connection */ if (filter_data_find(connection) == NULL) dbus_connection_remove_filter(connection, message_filter, NULL); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } static gboolean update_service(void *user_data) { struct service_data *data = user_data; struct filter_callback *cb = data->callback; update_name_cache(data->name, data->owner); if (cb->conn_func) cb->conn_func(data->conn, cb->user_data); service_data_free(data); return FALSE; } static void service_reply(DBusPendingCall *call, void *user_data) { struct service_data *data = user_data; DBusMessage *reply; DBusError err; reply = dbus_pending_call_steal_reply(call); if (reply == NULL) return; dbus_error_init(&err); if (dbus_set_error_from_message(&err, reply)) goto fail; if (dbus_message_get_args(reply, &err, DBUS_TYPE_STRING, &data->owner, DBUS_TYPE_INVALID) == FALSE) goto fail; update_service(data); goto done; fail: error("%s", err.message); dbus_error_free(&err); service_data_free(data); done: dbus_message_unref(reply); } static void check_service(DBusConnection *connection, const char *name, struct filter_callback *callback) { DBusMessage *message; struct service_data *data; data = g_try_malloc0(sizeof(*data)); if (data == NULL) { error("Can't allocate data structure"); return; } data->conn = dbus_connection_ref(connection); data->name = g_strdup(name); data->callback = callback; callback->data = data; data->owner = check_name_cache(name); if (data->owner != NULL) { data->id = g_idle_add(update_service, data); return; } message = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner"); if (message == NULL) { error("Can't allocate new message"); g_free(data); return; } dbus_message_append_args(message, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID); if (dbus_connection_send_with_reply(connection, message, &data->call, -1) == FALSE) { error("Failed to execute method call"); g_free(data); goto done; } if (data->call == NULL) { error("D-Bus connection not available"); g_free(data); goto done; } dbus_pending_call_set_notify(data->call, service_reply, data, NULL); done: dbus_message_unref(message); } guint g_dbus_add_service_watch(DBusConnection *connection, const char *name, GDBusWatchFunction connect, GDBusWatchFunction disconnect, void *user_data, GDBusDestroyFunction destroy) { struct filter_data *data; struct filter_callback *cb; if (name == NULL) return 0; data = filter_data_get(connection, service_filter, NULL, NULL, DBUS_INTERFACE_DBUS, "NameOwnerChanged", name); if (data == NULL) return 0; cb = filter_data_add_callback(data, connect, disconnect, NULL, destroy, user_data); if (cb == NULL) return 0; if (connect) check_service(connection, name, cb); return cb->id; } guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name, GDBusWatchFunction func, void *user_data, GDBusDestroyFunction destroy) { return g_dbus_add_service_watch(connection, name, NULL, func, user_data, destroy); } guint g_dbus_add_signal_watch(DBusConnection *connection, const char *sender, const char *path, const char *interface, const char *member, GDBusSignalFunction function, void *user_data, GDBusDestroyFunction destroy) { struct filter_data *data; struct filter_callback *cb; data = filter_data_get(connection, signal_filter, sender, path, interface, member, NULL); if (data == NULL) return 0; cb = filter_data_add_callback(data, NULL, NULL, function, destroy, user_data); if (cb == NULL) return 0; if (data->name != NULL && data->name_watch == 0) data->name_watch = g_dbus_add_service_watch(connection, data->name, NULL, NULL, NULL, NULL); return cb->id; } guint g_dbus_add_properties_watch(DBusConnection *connection, const char *sender, const char *path, const char *interface, GDBusSignalFunction function, void *user_data, GDBusDestroyFunction destroy) { struct filter_data *data; struct filter_callback *cb; data = filter_data_get(connection, signal_filter, sender, path, DBUS_INTERFACE_PROPERTIES, "PropertiesChanged", interface); if (data == NULL) return 0; cb = filter_data_add_callback(data, NULL, NULL, function, destroy, user_data); if (cb == NULL) return 0; if (data->name != NULL && data->name_watch == 0) data->name_watch = g_dbus_add_service_watch(connection, data->name, NULL, NULL, NULL, NULL); return cb->id; } gboolean g_dbus_remove_watch(DBusConnection *connection, guint id) { struct filter_data *data; struct filter_callback *cb; GSList *ldata; if (id == 0) return FALSE; for (ldata = listeners; ldata; ldata = ldata->next) { data = ldata->data; cb = filter_data_find_callback(data, id); if (cb) { filter_data_remove_callback(data, cb); return TRUE; } } return FALSE; } void g_dbus_remove_all_watches(DBusConnection *connection) { struct filter_data *data; while ((data = filter_data_find(connection))) { listeners = g_slist_remove(listeners, data); filter_data_call_and_free(data); } dbus_connection_remove_filter(connection, message_filter, NULL); } connman-ui-0_20150622+dfsg.orig/gdbus/gdbus.h0000644000175000017500000003024212541725135017137 0ustar nicknick/* * * D-Bus helper library * * Copyright (C) 2004-2011 Marcel Holtmann * * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef __GDBUS_H #define __GDBUS_H #ifdef __cplusplus extern "C" { #endif #include #include typedef enum GDBusMethodFlags GDBusMethodFlags; typedef enum GDBusSignalFlags GDBusSignalFlags; typedef enum GDBusPropertyFlags GDBusPropertyFlags; typedef enum GDBusSecurityFlags GDBusSecurityFlags; typedef struct GDBusArgInfo GDBusArgInfo; typedef struct GDBusMethodTable GDBusMethodTable; typedef struct GDBusSignalTable GDBusSignalTable; typedef struct GDBusPropertyTable GDBusPropertyTable; typedef struct GDBusSecurityTable GDBusSecurityTable; typedef void (* GDBusWatchFunction) (DBusConnection *connection, void *user_data); typedef void (* GDBusMessageFunction) (DBusConnection *connection, DBusMessage *message, void *user_data); typedef gboolean (* GDBusSignalFunction) (DBusConnection *connection, DBusMessage *message, void *user_data); DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name, DBusError *error); DBusConnection *g_dbus_setup_private(DBusBusType type, const char *name, DBusError *error); gboolean g_dbus_request_name(DBusConnection *connection, const char *name, DBusError *error); gboolean g_dbus_set_disconnect_function(DBusConnection *connection, GDBusWatchFunction function, void *user_data, DBusFreeFunction destroy); typedef void (* GDBusDestroyFunction) (void *user_data); typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection, DBusMessage *message, void *user_data); typedef gboolean (*GDBusPropertyGetter)(const GDBusPropertyTable *property, DBusMessageIter *iter, void *data); typedef guint32 GDBusPendingPropertySet; typedef void (*GDBusPropertySetter)(const GDBusPropertyTable *property, DBusMessageIter *value, GDBusPendingPropertySet id, void *data); typedef gboolean (*GDBusPropertyExists)(const GDBusPropertyTable *property, void *data); typedef guint32 GDBusPendingReply; typedef void (* GDBusSecurityFunction) (DBusConnection *connection, const char *action, gboolean interaction, GDBusPendingReply pending); enum GDBusFlags { G_DBUS_FLAG_ENABLE_EXPERIMENTAL = (1 << 0), }; enum GDBusMethodFlags { G_DBUS_METHOD_FLAG_DEPRECATED = (1 << 0), G_DBUS_METHOD_FLAG_NOREPLY = (1 << 1), G_DBUS_METHOD_FLAG_ASYNC = (1 << 2), G_DBUS_METHOD_FLAG_EXPERIMENTAL = (1 << 3), }; enum GDBusSignalFlags { G_DBUS_SIGNAL_FLAG_DEPRECATED = (1 << 0), G_DBUS_SIGNAL_FLAG_EXPERIMENTAL = (1 << 1), }; enum GDBusPropertyFlags { G_DBUS_PROPERTY_FLAG_DEPRECATED = (1 << 0), G_DBUS_PROPERTY_FLAG_EXPERIMENTAL = (1 << 1), }; enum GDBusSecurityFlags { G_DBUS_SECURITY_FLAG_DEPRECATED = (1 << 0), G_DBUS_SECURITY_FLAG_BUILTIN = (1 << 1), G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION = (1 << 2), }; struct GDBusArgInfo { const char *name; const char *signature; }; struct GDBusMethodTable { const char *name; GDBusMethodFunction function; GDBusMethodFlags flags; unsigned int privilege; const GDBusArgInfo *in_args; const GDBusArgInfo *out_args; }; struct GDBusSignalTable { const char *name; GDBusSignalFlags flags; const GDBusArgInfo *args; }; struct GDBusPropertyTable { const char *name; const char *type; GDBusPropertyGetter get; GDBusPropertySetter set; GDBusPropertyExists exists; GDBusPropertyFlags flags; }; struct GDBusSecurityTable { unsigned int privilege; const char *action; GDBusSecurityFlags flags; GDBusSecurityFunction function; }; #define GDBUS_ARGS(args...) (const GDBusArgInfo[]) { args, { } } #define GDBUS_METHOD(_name, _in_args, _out_args, _function) \ .name = _name, \ .in_args = _in_args, \ .out_args = _out_args, \ .function = _function #define GDBUS_ASYNC_METHOD(_name, _in_args, _out_args, _function) \ .name = _name, \ .in_args = _in_args, \ .out_args = _out_args, \ .function = _function, \ .flags = G_DBUS_METHOD_FLAG_ASYNC #define GDBUS_DEPRECATED_METHOD(_name, _in_args, _out_args, _function) \ .name = _name, \ .in_args = _in_args, \ .out_args = _out_args, \ .function = _function, \ .flags = G_DBUS_METHOD_FLAG_DEPRECATED #define GDBUS_DEPRECATED_ASYNC_METHOD(_name, _in_args, _out_args, _function) \ .name = _name, \ .in_args = _in_args, \ .out_args = _out_args, \ .function = _function, \ .flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_DEPRECATED #define GDBUS_EXPERIMENTAL_METHOD(_name, _in_args, _out_args, _function) \ .name = _name, \ .in_args = _in_args, \ .out_args = _out_args, \ .function = _function, \ .flags = G_DBUS_METHOD_FLAG_EXPERIMENTAL #define GDBUS_EXPERIMENTAL_ASYNC_METHOD(_name, _in_args, _out_args, _function) \ .name = _name, \ .in_args = _in_args, \ .out_args = _out_args, \ .function = _function, \ .flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_EXPERIMENTAL #define GDBUS_NOREPLY_METHOD(_name, _in_args, _out_args, _function) \ .name = _name, \ .in_args = _in_args, \ .out_args = _out_args, \ .function = _function, \ .flags = G_DBUS_METHOD_FLAG_NOREPLY #define GDBUS_SIGNAL(_name, _args) \ .name = _name, \ .args = _args #define GDBUS_DEPRECATED_SIGNAL(_name, _args) \ .name = _name, \ .args = _args, \ .flags = G_DBUS_SIGNAL_FLAG_DEPRECATED #define GDBUS_EXPERIMENTAL_SIGNAL(_name, _args) \ .name = _name, \ .args = _args, \ .flags = G_DBUS_SIGNAL_FLAG_EXPERIMENTAL void g_dbus_set_flags(int flags); gboolean g_dbus_register_interface(DBusConnection *connection, const char *path, const char *name, const GDBusMethodTable *methods, const GDBusSignalTable *signals, const GDBusPropertyTable *properties, void *user_data, GDBusDestroyFunction destroy); gboolean g_dbus_unregister_interface(DBusConnection *connection, const char *path, const char *name); gboolean g_dbus_register_security(const GDBusSecurityTable *security); gboolean g_dbus_unregister_security(const GDBusSecurityTable *security); void g_dbus_pending_success(DBusConnection *connection, GDBusPendingReply pending); void g_dbus_pending_error(DBusConnection *connection, GDBusPendingReply pending, const char *name, const char *format, ...) __attribute__((format(printf, 4, 5))); void g_dbus_pending_error_valist(DBusConnection *connection, GDBusPendingReply pending, const char *name, const char *format, va_list args); DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name, const char *format, ...) __attribute__((format(printf, 3, 4))); DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name, const char *format, va_list args); DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...); DBusMessage *g_dbus_create_reply_valist(DBusMessage *message, int type, va_list args); gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message); gboolean g_dbus_send_error(DBusConnection *connection, DBusMessage *message, const char *name, const char *format, ...) __attribute__((format(printf, 4, 5))); gboolean g_dbus_send_error_valist(DBusConnection *connection, DBusMessage *message, const char *name, const char *format, va_list args); gboolean g_dbus_send_reply(DBusConnection *connection, DBusMessage *message, int type, ...); gboolean g_dbus_send_reply_valist(DBusConnection *connection, DBusMessage *message, int type, va_list args); gboolean g_dbus_emit_signal(DBusConnection *connection, const char *path, const char *interface, const char *name, int type, ...); gboolean g_dbus_emit_signal_valist(DBusConnection *connection, const char *path, const char *interface, const char *name, int type, va_list args); guint g_dbus_add_service_watch(DBusConnection *connection, const char *name, GDBusWatchFunction connect, GDBusWatchFunction disconnect, void *user_data, GDBusDestroyFunction destroy); guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name, GDBusWatchFunction function, void *user_data, GDBusDestroyFunction destroy); guint g_dbus_add_signal_watch(DBusConnection *connection, const char *sender, const char *path, const char *interface, const char *member, GDBusSignalFunction function, void *user_data, GDBusDestroyFunction destroy); guint g_dbus_add_properties_watch(DBusConnection *connection, const char *sender, const char *path, const char *interface, GDBusSignalFunction function, void *user_data, GDBusDestroyFunction destroy); gboolean g_dbus_remove_watch(DBusConnection *connection, guint tag); void g_dbus_remove_all_watches(DBusConnection *connection); void g_dbus_pending_property_success(GDBusPendingPropertySet id); void g_dbus_pending_property_error_valist(GDBusPendingReply id, const char *name, const char *format, va_list args); void g_dbus_pending_property_error(GDBusPendingReply id, const char *name, const char *format, ...); void g_dbus_emit_property_changed(DBusConnection *connection, const char *path, const char *interface, const char *name); gboolean g_dbus_get_properties(DBusConnection *connection, const char *path, const char *interface, DBusMessageIter *iter); gboolean g_dbus_attach_object_manager(DBusConnection *connection); gboolean g_dbus_detach_object_manager(DBusConnection *connection); typedef struct GDBusClient GDBusClient; typedef struct GDBusProxy GDBusProxy; GDBusProxy *g_dbus_proxy_new(GDBusClient *client, const char *path, const char *interface); GDBusProxy *g_dbus_proxy_ref(GDBusProxy *proxy); void g_dbus_proxy_unref(GDBusProxy *proxy); const char *g_dbus_proxy_get_path(GDBusProxy *proxy); const char *g_dbus_proxy_get_interface(GDBusProxy *proxy); gboolean g_dbus_proxy_get_property(GDBusProxy *proxy, const char *name, DBusMessageIter *iter); gboolean g_dbus_proxy_refresh_property(GDBusProxy *proxy, const char *name); typedef void (* GDBusResultFunction) (const DBusError *error, void *user_data); gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy, const char *name, int type, const void *value, GDBusResultFunction function, void *user_data, GDBusDestroyFunction destroy); typedef void (* GDBusSetupFunction) (DBusMessageIter *iter, void *user_data); typedef void (* GDBusReturnFunction) (DBusMessage *message, void *user_data); gboolean g_dbus_proxy_method_call(GDBusProxy *proxy, const char *method, GDBusSetupFunction setup, GDBusReturnFunction function, void *user_data, GDBusDestroyFunction destroy); typedef void (* GDBusProxyFunction) (GDBusProxy *proxy, void *user_data); typedef void (* GDBusPropertyFunction) (GDBusProxy *proxy, const char *name, DBusMessageIter *iter, void *user_data); gboolean g_dbus_proxy_set_property_watch(GDBusProxy *proxy, GDBusPropertyFunction function, void *user_data); GDBusClient *g_dbus_client_new(DBusConnection *connection, const char *service, const char *path); GDBusClient *g_dbus_client_ref(GDBusClient *client); void g_dbus_client_unref(GDBusClient *client); gboolean g_dbus_client_set_connect_watch(GDBusClient *client, GDBusWatchFunction function, void *user_data); gboolean g_dbus_client_set_disconnect_watch(GDBusClient *client, GDBusWatchFunction function, void *user_data); gboolean g_dbus_client_set_signal_watch(GDBusClient *client, GDBusMessageFunction function, void *user_data); gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client, GDBusProxyFunction proxy_added, GDBusProxyFunction proxy_removed, GDBusPropertyFunction property_changed, void *user_data); #ifdef __cplusplus } #endif #endif /* __GDBUS_H */ connman-ui-0_20150622+dfsg.orig/bootstrap0000755000175000017500000000011612541725135016516 0ustar nicknick#!/bin/sh echo "Deprecated! Please use autogen.sh" >&2 exec ./autogen.sh "$@" connman-ui-0_20150622+dfsg.orig/po/0000755000175000017500000000000012541725135015173 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/po/ChangeLog0000644000175000017500000000000012541725135016733 0ustar nicknickconnman-ui-0_20150622+dfsg.orig/po/Makefile.in.in0000644000175000017500000001606012541725135017650 0ustar nicknick# Makefile for program source directory in GNU NLS utilities package. # Copyright (C) 1995, 1996, 1997 by Ulrich Drepper # Copyright (C) 2004-2008 Rodney Dawes # # This file may be copied and used freely without restrictions. It may # be used in projects which are not available under a GNU Public License, # but which still want to provide support for the GNU gettext functionality. # # - Modified by Owen Taylor to use GETTEXT_PACKAGE # instead of PACKAGE and to look for po2tbl in ./ not in intl/ # # - Modified by jacob berkman to install # Makefile.in.in and po2tbl.sed.in for use with glib-gettextize # # - Modified by Rodney Dawes for use with intltool # # We have the following line for use by intltoolize: # INTLTOOL_MAKEFILE GETTEXT_PACKAGE = @GETTEXT_PACKAGE@ PACKAGE = @PACKAGE@ VERSION = @VERSION@ SHELL = @SHELL@ srcdir = @srcdir@ top_srcdir = @top_srcdir@ top_builddir = @top_builddir@ VPATH = @srcdir@ prefix = @prefix@ exec_prefix = @exec_prefix@ datadir = @datadir@ datarootdir = @datarootdir@ libdir = @libdir@ localedir = @localedir@ subdir = po install_sh = @install_sh@ # Automake >= 1.8 provides @mkdir_p@. # Until it can be supposed, use the safe fallback: mkdir_p = $(install_sh) -d INSTALL = @INSTALL@ INSTALL_DATA = @INSTALL_DATA@ GMSGFMT = @GMSGFMT@ MSGFMT = @MSGFMT@ XGETTEXT = @XGETTEXT@ INTLTOOL_UPDATE = @INTLTOOL_UPDATE@ INTLTOOL_EXTRACT = @INTLTOOL_EXTRACT@ MSGMERGE = INTLTOOL_EXTRACT="$(INTLTOOL_EXTRACT)" XGETTEXT="$(XGETTEXT)" srcdir=$(srcdir) $(INTLTOOL_UPDATE) --gettext-package $(GETTEXT_PACKAGE) --dist GENPOT = INTLTOOL_EXTRACT="$(INTLTOOL_EXTRACT)" XGETTEXT="$(XGETTEXT)" srcdir=$(srcdir) $(INTLTOOL_UPDATE) --gettext-package $(GETTEXT_PACKAGE) --pot ALL_LINGUAS = @ALL_LINGUAS@ PO_LINGUAS=$(shell if test -r $(srcdir)/LINGUAS; then grep -v "^\#" $(srcdir)/LINGUAS; else echo "$(ALL_LINGUAS)"; fi) USER_LINGUAS=$(shell if test -n "$(LINGUAS)"; then LLINGUAS="$(LINGUAS)"; ALINGUAS="$(ALL_LINGUAS)"; for lang in $$LLINGUAS; do if test -n "`grep \^$$lang$$ $(srcdir)/LINGUAS 2>/dev/null`" -o -n "`echo $$ALINGUAS|tr ' ' '\n'|grep \^$$lang$$`"; then printf "$$lang "; fi; done; fi) USE_LINGUAS=$(shell if test -n "$(USER_LINGUAS)" -o -n "$(LINGUAS)"; then LLINGUAS="$(USER_LINGUAS)"; else if test -n "$(PO_LINGUAS)"; then LLINGUAS="$(PO_LINGUAS)"; else LLINGUAS="$(ALL_LINGUAS)"; fi; fi; for lang in $$LLINGUAS; do printf "$$lang "; done) POFILES=$(shell LINGUAS="$(PO_LINGUAS)"; for lang in $$LINGUAS; do if test -f "$$lang.po"; then printf "$$lang.po "; fi; done) DISTFILES = Makefile.in.in POTFILES.in $(POFILES) EXTRA_DISTFILES = ChangeLog POTFILES.skip Makevars LINGUAS POTFILES = \ # This comment gets stripped out CATALOGS=$(shell LINGUAS="$(USE_LINGUAS)"; for lang in $$LINGUAS; do if test -f "$$lang.po"; then printf "$$lang.gmo "; fi; done) .SUFFIXES: .SUFFIXES: .po .pox .gmo .mo .msg .cat AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ INTLTOOL_V_MSGFMT = $(INTLTOOL__v_MSGFMT_$(V)) INTLTOOL__v_MSGFMT_= $(INTLTOOL__v_MSGFMT_$(AM_DEFAULT_VERBOSITY)) INTLTOOL__v_MSGFMT_0 = @echo " MSGFMT" $@; .po.pox: $(MAKE) $(GETTEXT_PACKAGE).pot $(MSGMERGE) $< $(GETTEXT_PACKAGE).pot -o $*.pox .po.mo: $(INTLTOOL_V_MSGFMT)$(MSGFMT) -o $@ $< .po.gmo: $(INTLTOOL_V_MSGFMT)file=`echo $* | sed 's,.*/,,'`.gmo \ && rm -f $$file && $(GMSGFMT) -o $$file $< .po.cat: sed -f ../intl/po2msg.sed < $< > $*.msg \ && rm -f $@ && gencat $@ $*.msg all: all-@USE_NLS@ all-yes: $(CATALOGS) all-no: $(GETTEXT_PACKAGE).pot: $(POTFILES) $(GENPOT) install: install-data install-data: install-data-@USE_NLS@ install-data-no: all install-data-yes: all linguas="$(USE_LINGUAS)"; \ for lang in $$linguas; do \ dir=$(DESTDIR)$(localedir)/$$lang/LC_MESSAGES; \ $(mkdir_p) $$dir; \ if test -r $$lang.gmo; then \ $(INSTALL_DATA) $$lang.gmo $$dir/$(GETTEXT_PACKAGE).mo; \ echo "installing $$lang.gmo as $$dir/$(GETTEXT_PACKAGE).mo"; \ else \ $(INSTALL_DATA) $(srcdir)/$$lang.gmo $$dir/$(GETTEXT_PACKAGE).mo; \ echo "installing $(srcdir)/$$lang.gmo as" \ "$$dir/$(GETTEXT_PACKAGE).mo"; \ fi; \ if test -r $$lang.gmo.m; then \ $(INSTALL_DATA) $$lang.gmo.m $$dir/$(GETTEXT_PACKAGE).mo.m; \ echo "installing $$lang.gmo.m as $$dir/$(GETTEXT_PACKAGE).mo.m"; \ else \ if test -r $(srcdir)/$$lang.gmo.m ; then \ $(INSTALL_DATA) $(srcdir)/$$lang.gmo.m \ $$dir/$(GETTEXT_PACKAGE).mo.m; \ echo "installing $(srcdir)/$$lang.gmo.m as" \ "$$dir/$(GETTEXT_PACKAGE).mo.m"; \ else \ true; \ fi; \ fi; \ done # Empty stubs to satisfy archaic automake needs dvi info ctags tags CTAGS TAGS ID: # Define this as empty until I found a useful application. install-exec installcheck: uninstall: linguas="$(USE_LINGUAS)"; \ for lang in $$linguas; do \ rm -f $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE).mo; \ rm -f $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE).mo.m; \ done check: all $(GETTEXT_PACKAGE).pot rm -f missing notexist srcdir=$(srcdir) $(INTLTOOL_UPDATE) -m if [ -r missing -o -r notexist ]; then \ exit 1; \ fi mostlyclean: rm -f *.pox $(GETTEXT_PACKAGE).pot *.old.po cat-id-tbl.tmp rm -f .intltool-merge-cache clean: mostlyclean distclean: clean rm -f Makefile Makefile.in POTFILES stamp-it rm -f *.mo *.msg *.cat *.cat.m *.gmo maintainer-clean: distclean @echo "This command is intended for maintainers to use;" @echo "it deletes files that may require special tools to rebuild." rm -f Makefile.in.in distdir = ../$(PACKAGE)-$(VERSION)/$(subdir) dist distdir: $(DISTFILES) dists="$(DISTFILES)"; \ extra_dists="$(EXTRA_DISTFILES)"; \ for file in $$extra_dists; do \ test -f $(srcdir)/$$file && dists="$$dists $(srcdir)/$$file"; \ done; \ for file in $$dists; do \ test -f $$file || file="$(srcdir)/$$file"; \ ln $$file $(distdir) 2> /dev/null \ || cp -p $$file $(distdir); \ done update-po: Makefile $(MAKE) $(GETTEXT_PACKAGE).pot tmpdir=`pwd`; \ linguas="$(USE_LINGUAS)"; \ for lang in $$linguas; do \ echo "$$lang:"; \ result="`$(MSGMERGE) -o $$tmpdir/$$lang.new.po $$lang`"; \ if $$result; then \ if cmp $(srcdir)/$$lang.po $$tmpdir/$$lang.new.po >/dev/null 2>&1; then \ rm -f $$tmpdir/$$lang.new.po; \ else \ if mv -f $$tmpdir/$$lang.new.po $$lang.po; then \ :; \ else \ echo "msgmerge for $$lang.po failed: cannot move $$tmpdir/$$lang.new.po to $$lang.po" 1>&2; \ rm -f $$tmpdir/$$lang.new.po; \ exit 1; \ fi; \ fi; \ else \ echo "msgmerge for $$lang.gmo failed!"; \ rm -f $$tmpdir/$$lang.new.po; \ fi; \ done Makefile POTFILES: stamp-it @if test ! -f $@; then \ rm -f stamp-it; \ $(MAKE) stamp-it; \ fi stamp-it: Makefile.in.in $(top_builddir)/config.status POTFILES.in cd $(top_builddir) \ && CONFIG_FILES=$(subdir)/Makefile.in CONFIG_HEADERS= CONFIG_LINKS= \ $(SHELL) ./config.status # Tell versions [3.59,3.63) of GNU make not to export all variables. # Otherwise a system limit (for SysV at least) may be exceeded. .NOEXPORT: connman-ui-0_20150622+dfsg.orig/po/zh_CN.po0000644000175000017500000001566112541725135016545 0ustar nicknick# Simplified Chinese translation for connman-ui. # Copyright (C) 2015 Timothy Lee # This file is distributed under the same license as the connman-ui package. # Timothy Lee , 2015. # msgid "" msgstr "" "Project-Id-Version: connman-ui\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2015-04-11 11:21+0800\n" "PO-Revision-Date: 2015-04-11 11:21+0800\n" "Last-Translator: \n" "Language-Team: Timothy Lee \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 1.5.5\n" "Language: zh-CN\n" #: ../data/ui/agent.ui.h:1 msgid "Retry" msgstr "é‡è¯•" #: ../data/ui/agent.ui.h:2 msgid " Error " msgstr " 错误 " #: ../data/ui/agent.ui.h:3 msgid "Network " msgstr "网络 " #: ../data/ui/agent.ui.h:4 msgid "requires information to get connected" msgstr "连接须æ供数æ®" #: ../data/ui/agent.ui.h:5 msgid "Name:" msgstr "å称：" #: ../data/ui/agent.ui.h:6 msgid "Identity:" msgstr "身份：" #: ../data/ui/agent.ui.h:7 msgid "Passphrase:" msgstr "Passphrase:" #: ../data/ui/agent.ui.h:8 msgid "minimum 8 characters" msgstr "最少 8 个字符" #: ../data/ui/agent.ui.h:9 msgid "Previous Passphrase:" msgstr "å‰ä¸€ä¸ªå£ä»¤ï¼š" #: ../data/ui/agent.ui.h:10 msgid "You are probably trying to connect to a Hotspot." msgstr "你应该在å°è¯•è¿žæŽ¥è‡³ä¸€ä¸ªçƒ­ç‚¹ã€‚" #: ../data/ui/agent.ui.h:11 msgid "" " Login is required to get\n" "plain access to the network" msgstr "" " 你必须登录\n" "æ‰èƒ½è®¿é—®ç½‘络" #: ../data/ui/agent.ui.h:13 msgid "Username: " msgstr "用户å称：" #: ../data/ui/agent.ui.h:14 msgid "Password: " msgstr "å£ä»¤ï¼š" #: ../data/ui/agent.ui.h:15 msgid "Shared WiFi connection information" msgstr "共享 WiFi 的连接数æ®" #: ../data/ui/agent.ui.h:16 msgid "SSID: " msgstr "SSID：" #: ../data/ui/agent.ui.h:17 msgid "Passphrase: " msgstr "å£ä»¤ï¼š" #: ../data/ui/left_menu.ui.h:1 msgid "Available networks" msgstr "å¯ç”¨ç½‘络" #: ../data/ui/left_menu.ui.h:2 msgid "Scanning..." msgstr "扫æ中……" #: ../data/ui/left_menu.ui.h:3 msgid "More networks ..." msgstr "更多网络……" #: ../data/ui/right_menu.ui.h:1 msgid "Airplane Mode" msgstr "飞行模å¼" #: ../data/ui/right_menu.ui.h:2 msgid "unset airplane mode" msgstr "åœç”¨é£žè¡Œæ¨¡å¼" #: ../data/ui/right_menu.ui.h:3 msgid "set airplane mode" msgstr "打开飞行模å¼" #: ../data/ui/right_menu.ui.h:4 msgid "Share connection" msgstr "共享连接" #: ../data/ui/right_menu.ui.h:5 msgid "Share your connection (tethering)" msgstr "共享你的连接（tethering）" #: ../data/ui/right_menu.ui.h:6 msgid "Quit ConnMan-UI" msgstr "离开 ConnMan-UI" #: ../data/ui/settings.ui.h:1 msgid "Autoconnect" msgstr "自动连接" #: ../data/ui/settings.ui.h:2 msgid "Favorite" msgstr "我的最爱" #: ../data/ui/settings.ui.h:3 msgid "Method: " msgstr "æ–¹å¼ï¼š" #: ../data/ui/settings.ui.h:4 msgid "DHCP" msgstr "DHCP" #: ../data/ui/settings.ui.h:5 msgid "Manual" msgstr "手动" #: ../data/ui/settings.ui.h:6 msgid "Off" msgstr "åœç”¨" #: ../data/ui/settings.ui.h:7 msgid "Address:" msgstr "地å€ï¼š" #: ../data/ui/settings.ui.h:8 msgid "Netmask:" msgstr "网络掩ç ï¼š" #: ../data/ui/settings.ui.h:9 msgid "Gateway:" msgstr "网关：" #: ../data/ui/settings.ui.h:10 msgid "IPv4 Settings" msgstr "IPv4 设置" #: ../data/ui/settings.ui.h:11 msgid "Auto" msgstr "自动" #: ../data/ui/settings.ui.h:12 msgid "Prefix length:" msgstr "å‰ç¼€é•¿åº¦ï¼š" #: ../data/ui/settings.ui.h:13 msgid "Privacy: " msgstr "ç§éšï¼š" #: ../data/ui/settings.ui.h:14 msgid "Prefered" msgstr "首选" #: ../data/ui/settings.ui.h:15 msgid "Enabled" msgstr "å·²å¯ç”¨" #: ../data/ui/settings.ui.h:16 msgid "Disabled" msgstr "å·²åœç”¨" #: ../data/ui/settings.ui.h:17 msgid "IPv6 Settings" msgstr "IPv6 设置" #: ../data/ui/settings.ui.h:18 msgid "Name servers" msgstr "å称æœåŠ¡å™¨" #: ../data/ui/settings.ui.h:19 msgid "In use:" msgstr "使用中：" #: ../data/ui/settings.ui.h:20 msgid "Configuration:" msgstr "设置：" #: ../data/ui/settings.ui.h:21 msgid "One or multiple IPs separated by ';'" msgstr "一个或多个以「;ã€åˆ†éš”çš„ IP" #: ../data/ui/settings.ui.h:22 msgid "Domains" msgstr "网域" #: ../data/ui/settings.ui.h:23 msgid "One ore many domains separated by ';'" msgstr "一个或多个以「;ã€åˆ†éš”的网域" #: ../data/ui/settings.ui.h:24 msgid "DNS Settings" msgstr "DNS 设置" #: ../data/ui/settings.ui.h:25 msgid "Method:" msgstr "æ–¹å¼ï¼š" #: ../data/ui/settings.ui.h:26 msgid "Direct" msgstr "直接" #: ../data/ui/settings.ui.h:27 msgid "URL:" msgstr "URL：" #: ../data/ui/settings.ui.h:28 msgid "Servers:" msgstr "æœåŠ¡å™¨ï¼š" #: ../data/ui/settings.ui.h:29 msgid "Excludes:" msgstr "排除：" #: ../data/ui/settings.ui.h:30 msgid "Proxy Settings" msgstr "代ç†æœåŠ¡å™¨è®¾ç½®ï¼š" #: ../data/ui/settings.ui.h:31 msgid "One or many IPs/hostnames separated by ';'" msgstr "一个或多个以「;ã€åˆ†éš”çš„ IPï¼ä¸»æœºå称" #: ../data/ui/settings.ui.h:32 msgid "Time servers Settings" msgstr "时间æœåŠ¡å™¨è®¾ç½®" #: ../data/ui/settings.ui.h:33 msgid "Interface: " msgstr "ç•Œé¢ï¼š" #: ../data/ui/settings.ui.h:34 msgid "Address: " msgstr "地å€ï¼š" #: ../data/ui/settings.ui.h:35 msgid " MTU: " msgstr " MTU：" #: ../data/ui/settings.ui.h:36 msgid " Speed: " msgstr " 速度：" #: ../data/ui/settings.ui.h:37 msgid " Duplex: " msgstr " åŒå·¥ï¼š" #: ../data/ui/settings.ui.h:38 msgid "Ethernet information" msgstr " 以太网设置" #: ../data/ui/settings.ui.h:39 msgid "Host: " msgstr "主机：" #: ../data/ui/settings.ui.h:40 msgid "Domain: " msgstr "网域：" #: ../data/ui/settings.ui.h:41 msgid " Name: " msgstr " å称：" #: ../data/ui/settings.ui.h:42 msgid " Type: " msgstr " 类型：" #: ../data/ui/settings.ui.h:43 msgid "VPN provider information" msgstr "VPN 供应者数æ®" #: ../src/agent_dialogs.c:107 #, c-format msgid "" "Previous Passphrase:\n" "%s" msgstr "" "å‰ä¸€ä¸ªå£ä»¤ï¼š\n" "%s" #: ../src/gtktechnology.c:268 msgid "" "Left click to enable/disable\n" "Right click to set tethering information" msgstr "" "按左键å¯ç”¨ï¼åœç”¨\n" "按å³é”®è®¾ç½® tethering æ•°æ®" #: ../src/gtktechnology.c:272 msgid "Left to enable/disable" msgstr "按左键å¯ç”¨ï¼åœç”¨" #: ../src/theme.c:33 msgid "Tethering" msgstr "Tethering" #: ../src/theme.c:45 msgid "Ethernet" msgstr "以太网" #: ../src/theme.c:49 msgid "Cellular" msgstr "æµåŠ¨ç½‘络" #: ../src/theme.c:68 msgid "Very good signal" msgstr "ä¿¡å·éžå¸¸è‰¯å¥½" #: ../src/theme.c:72 msgid "Good signal" msgstr "ä¿¡å·è‰¯å¥½" #: ../src/theme.c:76 msgid "Low signal" msgstr "ä¿¡å·å¾®å¼±" #: ../src/theme.c:80 msgid "Very low signal" msgstr "ä¿¡å·éžå¸¸å¾®å¼±" #: ../src/theme.c:102 msgid "Connman is not running" msgstr "未有执行 Connman" #: ../src/theme.c:107 msgid "Connected" msgstr "已连接" #: ../src/theme.c:112 msgid "Online" msgstr "è”机" #: ../src/theme.c:117 msgid "Disconnected" msgstr "未连接" connman-ui-0_20150622+dfsg.orig/po/fr.po0000644000175000017500000001574012541725135016151 0ustar nicknick# # Copyright (C) 2012 Intel Corporation. All rights reserved. # This file is distributed under the same license as the Connman UI package. # Tomasz Bursztyka , 2012. # msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2012-12-21 15:06+0200\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: Tomasz Bursztyka \n" "Language-Team: \n" "Language: \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" #: ../data/ui/agent.ui.h:1 msgid "Retry" msgstr "Réessayer" #: ../data/ui/agent.ui.h:2 msgid " Error " msgstr " Erreur " #: ../data/ui/agent.ui.h:3 msgid "Network " msgstr "Réseau" #: ../data/ui/agent.ui.h:4 msgid "requires information to get connected" msgstr "requiert des informations supplémentaires pour être connecté" #: ../data/ui/agent.ui.h:5 msgid "Name:" msgstr "Nom:" #: ../data/ui/agent.ui.h:6 msgid "Identity:" msgstr "Identité:" #: ../data/ui/agent.ui.h:7 msgid "Passphrase:" msgstr "Mot de passe:" #: ../data/ui/agent.ui.h:8 msgid "minimum 8 characters" msgstr "8 caractères minimum" #: ../data/ui/agent.ui.h:9 msgid "Previous Passphrase:" msgstr "Mot de passe précédent:" #: ../data/ui/agent.ui.h:10 msgid "You are probably trying to connect to a Hotspot." msgstr "Vous tentez probablement de vous connecter à un Hostpot" #: ../data/ui/agent.ui.h:11 msgid "" " Login is required to get\n" "plain access to the network" msgstr "" " Il est nécessaire de vous identifier\n" "afin d'obtenir un accès complet au réseau" #: ../data/ui/agent.ui.h:13 msgid "Username: " msgstr "Utilisateur: " #: ../data/ui/agent.ui.h:14 msgid "Password: " msgstr "Mot de passe: " #: ../data/ui/agent.ui.h:15 msgid "Shared WiFi connection information" msgstr "Informations relatives au partage de connexion WiFi" #: ../data/ui/agent.ui.h:16 msgid "SSID: " msgstr "" #: ../data/ui/agent.ui.h:17 msgid "Passphrase: " msgstr "Mot de passe: " #: ../data/ui/left_menu.ui.h:1 msgid "Available networks" msgstr "Réseaux disponibles" #: ../data/ui/left_menu.ui.h:2 msgid "Scanning..." msgstr "Scan..." #: ../data/ui/left_menu.ui.h:3 msgid "More networks ..." msgstr "Plus de réseaux ..." #: ../data/ui/right_menu.ui.h:1 msgid "Airplane Mode" msgstr "" #: ../data/ui/right_menu.ui.h:2 msgid "unset airplane mode" msgstr "" #: ../data/ui/right_menu.ui.h:3 msgid "set airplane mode" msgstr "" #: ../data/ui/right_menu.ui.h:4 msgid "Share connection" msgstr "Partage de connexion" #: ../data/ui/right_menu.ui.h:5 msgid "Share your connection (tethering)" msgstr "Partager votre connexion" #: ../data/ui/right_menu.ui.h:6 msgid "Quit ConnMan-UI" msgstr "Quitter ConnMan-UI" #: ../data/ui/settings.ui.h:1 msgid "Autoconnect" msgstr "Auto-connexion" #: ../data/ui/settings.ui.h:2 msgid "Favorite" msgstr "Favori" #: ../data/ui/settings.ui.h:3 msgid "Method: " msgstr "Méthode: " #: ../data/ui/settings.ui.h:4 msgid "DHCP" msgstr "" #: ../data/ui/settings.ui.h:5 msgid "Manual" msgstr "Manuel" #: ../data/ui/settings.ui.h:6 msgid "Off" msgstr "" #: ../data/ui/settings.ui.h:7 msgid "Address:" msgstr "Adresse:" #: ../data/ui/settings.ui.h:8 msgid "Netmask:" msgstr "Masque de sous-réseau:" #: ../data/ui/settings.ui.h:9 msgid "Gateway:" msgstr "Routeur:" #: ../data/ui/settings.ui.h:10 msgid "IPv4 Settings" msgstr "Configurations IPv4" #: ../data/ui/settings.ui.h:11 msgid "Auto" msgstr "" #: ../data/ui/settings.ui.h:12 msgid "Prefix length:" msgstr "Préfixe:" #: ../data/ui/settings.ui.h:13 msgid "Privacy: " msgstr "IPv6 aléatoire:" #: ../data/ui/settings.ui.h:14 msgid "Prefered" msgstr "Auto" #: ../data/ui/settings.ui.h:15 msgid "Enabled" msgstr "On" #: ../data/ui/settings.ui.h:16 msgid "Disabled" msgstr "Off" #: ../data/ui/settings.ui.h:17 msgid "IPv6 Settings" msgstr "Configuration IPv6" #: ../data/ui/settings.ui.h:18 msgid "Name servers" msgstr "Serveurs de noms" #: ../data/ui/settings.ui.h:19 msgid "In use:" msgstr "Actuel:" #: ../data/ui/settings.ui.h:20 msgid "Configuration:" msgstr "" #: ../data/ui/settings.ui.h:21 msgid "One or multiple IPs separated by ';'" msgstr "Une ou plusieurs IP séparées par ';'" #: ../data/ui/settings.ui.h:22 msgid "Domains" msgstr "Domaines" #: ../data/ui/settings.ui.h:23 msgid "One ore many domains separated by ';'" msgstr "Un ou plusieurs domaines séparés par ';'" #: ../data/ui/settings.ui.h:24 msgid "DNS Settings" msgstr "Configuration DNS" #: ../data/ui/settings.ui.h:25 msgid "Method:" msgstr "Méthode" #: ../data/ui/settings.ui.h:26 msgid "Direct" msgstr "" #: ../data/ui/settings.ui.h:27 msgid "URL:" msgstr "" #: ../data/ui/settings.ui.h:28 msgid "Servers:" msgstr "Serveurs:" #: ../data/ui/settings.ui.h:29 msgid "Excludes:" msgstr "Exclusions:" #: ../data/ui/settings.ui.h:30 msgid "Proxy Settings" msgstr "Configurations du proxy" #: ../data/ui/settings.ui.h:31 msgid "One or many IPs/hostnames separated by ';'" msgstr "Un/e ou plusieurs domaines/IP séparé(e)s par ';'" #: ../data/ui/settings.ui.h:32 msgid "Time servers Settings" msgstr "Configuration des serveurs d'horloge" #: ../data/ui/settings.ui.h:33 msgid "Interface: " msgstr "" #: ../data/ui/settings.ui.h:34 msgid "Address: " msgstr "Adresse: " #: ../data/ui/settings.ui.h:35 msgid " MTU: " msgstr "" #: ../data/ui/settings.ui.h:36 msgid " Speed: " msgstr " Vitesse: " #: ../data/ui/settings.ui.h:37 msgid " Duplex: " msgstr "" #: ../data/ui/settings.ui.h:38 msgid "Ethernet information" msgstr "Information ethernet" #: ../data/ui/settings.ui.h:39 msgid "Host: " msgstr "Serveur: " #: ../data/ui/settings.ui.h:40 msgid "Domain: " msgstr "Domaine: " #: ../data/ui/settings.ui.h:41 msgid " Name: " msgstr " Nom: " #: ../data/ui/settings.ui.h:42 msgid " Type: " msgstr "" #: ../data/ui/settings.ui.h:43 msgid "VPN provider information" msgstr "Informations VPN" #: ../src/agent_dialogs.c:107 #, c-format msgid "" "Previous Passphrase:\n" "%s" msgstr "Passphrase précédente:\n" "%s" #: ../src/gtktechnology.c:268 msgid "" "Left click to enable/disable\n" "Right click to set tethering informations" msgstr "" "Click gauche pour On/Off\n" "Click droit pour configurer les \n" "informations de partage de connexion" #: ../src/gtktechnology.c:272 msgid "Left to enable/disable" msgstr "Click gauche pour On/Off" #: ../src/theme.c:33 msgid "Tethering" msgstr "" #: ../src/theme.c:45 msgid "Ethernet" msgstr "" #: ../src/theme.c:49 msgid "Cellular" msgstr "Cellulaire" #: ../src/theme.c:68 msgid "Very good signal" msgstr "Très bon signal" #: ../src/theme.c:72 msgid "Good signal" msgstr "Bon signal" #: ../src/theme.c:76 msgid "Low signal" msgstr "Mauvais signal" #: ../src/theme.c:80 msgid "Very low signal" msgstr "Très mauvais signal" #: ../src/theme.c:102 msgid "Connman is not running" msgstr "Connman n'est pas démarré" #: ../src/theme.c:107 msgid "Connected" msgstr "Connecté" #: ../src/theme.c:112 msgid "Online" msgstr "En ligne" #: ../src/theme.c:117 msgid "Disconnected" msgstr "Déconnecté" connman-ui-0_20150622+dfsg.orig/po/es.po0000644000175000017500000001643612541725135016154 0ustar nicknick# # Copyright (C) 2015 Adolfo Jayme Barrientos. All rights reserved. # This file is distributed under the same license as the Connman UI package. # Adolfo Jayme Barrientos , 2015. # msgid "" msgstr "" "Project-Id-Version: \n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2012-12-21 15:06+0200\n" "PO-Revision-Date: 2015-06-06 20:51-0600\n" "Last-Translator: Adolfo Jayme Barrientos \n" "Language-Team: \n" "Language: es\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "X-Generator: Poedit 1.7.7\n" #: ../data/ui/agent.ui.h:1 msgid "Retry" msgstr "Reintentar" #: ../data/ui/agent.ui.h:2 msgid " Error " msgstr " Error " #: ../data/ui/agent.ui.h:3 msgid "Network " msgstr "Red" #: ../data/ui/agent.ui.h:4 msgid "requires information to get connected" msgstr "necesita información para efectuar la conexión" #: ../data/ui/agent.ui.h:5 msgid "Name:" msgstr "Nombre:" #: ../data/ui/agent.ui.h:6 msgid "Identity:" msgstr "Identidad:" #: ../data/ui/agent.ui.h:7 msgid "Passphrase:" msgstr "Frase de contraseña:" #: ../data/ui/agent.ui.h:8 msgid "minimum 8 characters" msgstr "8 caracteres como mínimo" #: ../data/ui/agent.ui.h:9 msgid "Previous Passphrase:" msgstr "Contraseña anterior:" #: ../data/ui/agent.ui.h:10 msgid "You are probably trying to connect to a Hotspot." msgstr "Probablemente está intentando conectar con un «hotspot»." #: ../data/ui/agent.ui.h:11 msgid "" " Login is required to get\n" "plain access to the network" msgstr "" " Es necesario acceder para\n" "obtener acceso a la red" #: ../data/ui/agent.ui.h:13 msgid "Username: " msgstr "Nombre de usuario: " #: ../data/ui/agent.ui.h:14 msgid "Password: " msgstr "Contraseña: " #: ../data/ui/agent.ui.h:15 msgid "Shared WiFi connection information" msgstr "Información sobre la conexión wifi compartida" #: ../data/ui/agent.ui.h:16 msgid "SSID: " msgstr "SSID: " #: ../data/ui/agent.ui.h:17 msgid "Passphrase: " msgstr "Frase de contraseña: " #: ../data/ui/left_menu.ui.h:1 msgid "Available networks" msgstr "Redes disponibles" #: ../data/ui/left_menu.ui.h:2 msgid "Scanning..." msgstr "Explorando…" #: ../data/ui/left_menu.ui.h:3 msgid "More networks ..." msgstr "Más redes…" #: ../data/ui/right_menu.ui.h:1 msgid "Airplane Mode" msgstr "Modo avión" #: ../data/ui/right_menu.ui.h:2 msgid "unset airplane mode" msgstr "desactivar modo avión" #: ../data/ui/right_menu.ui.h:3 msgid "set airplane mode" msgstr "activar modo avión" #: ../data/ui/right_menu.ui.h:4 msgid "Share connection" msgstr "Compartir conexión" #: ../data/ui/right_menu.ui.h:5 msgid "Share your connection (tethering)" msgstr "Compartir conexión («tethering»)" #: ../data/ui/right_menu.ui.h:6 msgid "Quit ConnMan-UI" msgstr "Salir de ConnMan-UI" #: ../data/ui/settings.ui.h:1 msgid "Autoconnect" msgstr "Conectar automáticamente" #: ../data/ui/settings.ui.h:2 msgid "Favorite" msgstr "Favorito" #: ../data/ui/settings.ui.h:3 msgid "Method: " msgstr "Método: " #: ../data/ui/settings.ui.h:4 msgid "DHCP" msgstr "DHCP" #: ../data/ui/settings.ui.h:5 msgid "Manual" msgstr "Manual" #: ../data/ui/settings.ui.h:6 msgid "Off" msgstr "Apagado" #: ../data/ui/settings.ui.h:7 msgid "Address:" msgstr "Dirección:" #: ../data/ui/settings.ui.h:8 msgid "Netmask:" msgstr "Máscara de red:" #: ../data/ui/settings.ui.h:9 msgid "Gateway:" msgstr "Puerta de enlace:" #: ../data/ui/settings.ui.h:10 msgid "IPv4 Settings" msgstr "Configuración de IPv4" #: ../data/ui/settings.ui.h:11 msgid "Auto" msgstr "Automático" #: ../data/ui/settings.ui.h:12 msgid "Prefix length:" msgstr "Longitud de prefijo:" #: ../data/ui/settings.ui.h:13 msgid "Privacy: " msgstr "Privacidad: " #: ../data/ui/settings.ui.h:14 msgid "Prefered" msgstr "Preferida" #: ../data/ui/settings.ui.h:15 msgid "Enabled" msgstr "Activada" #: ../data/ui/settings.ui.h:16 msgid "Disabled" msgstr "Desactivada" #: ../data/ui/settings.ui.h:17 msgid "IPv6 Settings" msgstr "Configuración de IPv6" #: ../data/ui/settings.ui.h:18 msgid "Name servers" msgstr "Servidores de nombres" #: ../data/ui/settings.ui.h:19 msgid "In use:" msgstr "En uso:" #: ../data/ui/settings.ui.h:20 msgid "Configuration:" msgstr "Configuración:" #: ../data/ui/settings.ui.h:21 msgid "One or multiple IPs separated by ';'" msgstr "Una o más IP separadas por «;»" #: ../data/ui/settings.ui.h:22 msgid "Domains" msgstr "Dominios" #: ../data/ui/settings.ui.h:23 msgid "One ore many domains separated by ';'" msgstr "Uno o más dominios separados por «;»" #: ../data/ui/settings.ui.h:24 msgid "DNS Settings" msgstr "Configuración de DNS" #: ../data/ui/settings.ui.h:25 msgid "Method:" msgstr "Método:" #: ../data/ui/settings.ui.h:26 msgid "Direct" msgstr "Directa" #: ../data/ui/settings.ui.h:27 msgid "URL:" msgstr "URL:" #: ../data/ui/settings.ui.h:28 msgid "Servers:" msgstr "Servidores:" #: ../data/ui/settings.ui.h:29 msgid "Excludes:" msgstr "Exclusiones:" #: ../data/ui/settings.ui.h:30 msgid "Proxy Settings" msgstr "Configuración de «proxy»" #: ../data/ui/settings.ui.h:31 msgid "One or many IPs/hostnames separated by ';'" msgstr "Uno o más equipos o IP separados por «;»" #: ../data/ui/settings.ui.h:32 msgid "Time servers Settings" msgstr "Configuración de servidores de hora" #: ../data/ui/settings.ui.h:33 msgid "Interface: " msgstr "Interfaz: " #: ../data/ui/settings.ui.h:34 msgid "Address: " msgstr "Dirección: " #: ../data/ui/settings.ui.h:35 msgid " MTU: " msgstr " MTU: " #: ../data/ui/settings.ui.h:36 msgid " Speed: " msgstr " Velocidad: " #: ../data/ui/settings.ui.h:37 msgid " Duplex: " msgstr " Dúplex: " #: ../data/ui/settings.ui.h:38 msgid "Ethernet information" msgstr "Información de Ethernet" #: ../data/ui/settings.ui.h:39 msgid "Host: " msgstr "Equipo: " #: ../data/ui/settings.ui.h:40 msgid "Domain: " msgstr "Dominio: " #: ../data/ui/settings.ui.h:41 msgid " Name: " msgstr " Nombre: " #: ../data/ui/settings.ui.h:42 msgid " Type: " msgstr " Tipo: " #: ../data/ui/settings.ui.h:43 msgid "VPN provider information" msgstr "Información de proveedor de VPN" #: ../src/agent_dialogs.c:107 #, c-format msgid "" "Previous Passphrase:\n" "%s" msgstr "" "Frase de contraseña anterior:\n" "%s" #: ../src/gtktechnology.c:268 msgid "" "Left click to enable/disable\n" "Right click to set tethering informations" msgstr "" "Pulse para activar/desactivar\n" "Pulse con el botón secundario para establecer info. de «tethering»" #: ../src/gtktechnology.c:272 msgid "Left to enable/disable" msgstr "Pulse para activar/desactivar" #: ../src/theme.c:33 msgid "Tethering" msgstr "«Tethering»" #: ../src/theme.c:45 msgid "Ethernet" msgstr "Ethernet" #: ../src/theme.c:49 msgid "Cellular" msgstr "Datos móviles" #: ../src/theme.c:68 msgid "Very good signal" msgstr "Señal muy buena" #: ../src/theme.c:72 msgid "Good signal" msgstr "Señal buena" #: ../src/theme.c:76 msgid "Low signal" msgstr "Señal baja" #: ../src/theme.c:80 msgid "Very low signal" msgstr "Señal muy baja" #: ../src/theme.c:102 msgid "Connman is not running" msgstr "Connman no se está ejecutando" #: ../src/theme.c:107 msgid "Connected" msgstr "Conectado" #: ../src/theme.c:112 msgid "Online" msgstr "En línea" #: ../src/theme.c:117 msgid "Disconnected" msgstr "Desconectado" connman-ui-0_20150622+dfsg.orig/po/zh_HK.po0000644000175000017500000001567612541725135016555 0ustar nicknick# Traditional Chinese (Hong Kong) translation for connman-ui. # Copyright (C) 2015 Timothy Lee # This file is distributed under the same license as the connman-ui package. # Timothy Lee , 2015. # msgid "" msgstr "" "Project-Id-Version: connman-ui\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2015-04-11 11:21+0800\n" "PO-Revision-Date: 2015-04-11 11:21+0800\n" "Last-Translator: \n" "Language-Team: Timothy Lee \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 1.5.5\n" "Language: zh-HK\n" #: ../data/ui/agent.ui.h:1 msgid "Retry" msgstr "é‡è©¦" #: ../data/ui/agent.ui.h:2 msgid " Error " msgstr " 錯誤 " #: ../data/ui/agent.ui.h:3 msgid "Network " msgstr "網絡 " #: ../data/ui/agent.ui.h:4 msgid "requires information to get connected" msgstr "連線須æ供資料" #: ../data/ui/agent.ui.h:5 msgid "Name:" msgstr "å稱：" #: ../data/ui/agent.ui.h:6 msgid "Identity:" msgstr "身份：" #: ../data/ui/agent.ui.h:7 msgid "Passphrase:" msgstr "Passphrase:" #: ../data/ui/agent.ui.h:8 msgid "minimum 8 characters" msgstr "最少 8 個字元" #: ../data/ui/agent.ui.h:9 msgid "Previous Passphrase:" msgstr "å‰ä¸€å€‹å¯†ç¢¼ï¼š" #: ../data/ui/agent.ui.h:10 msgid "You are probably trying to connect to a Hotspot." msgstr "你應該在嘗試連線至一個熱點。" #: ../data/ui/agent.ui.h:11 msgid "" " Login is required to get\n" "plain access to the network" msgstr "" " 你必須登入\n" "æ‰èƒ½å­˜å–網絡" #: ../data/ui/agent.ui.h:13 msgid "Username: " msgstr "用戶å稱：" #: ../data/ui/agent.ui.h:14 msgid "Password: " msgstr "密碼：" #: ../data/ui/agent.ui.h:15 msgid "Shared WiFi connection information" msgstr "共享 WiFi 的連線資料" #: ../data/ui/agent.ui.h:16 msgid "SSID: " msgstr "SSID：" #: ../data/ui/agent.ui.h:17 msgid "Passphrase: " msgstr "密碼：" #: ../data/ui/left_menu.ui.h:1 msgid "Available networks" msgstr "å¯ç”¨ç¶²çµ¡" #: ../data/ui/left_menu.ui.h:2 msgid "Scanning..." msgstr "掃æ中……" #: ../data/ui/left_menu.ui.h:3 msgid "More networks ..." msgstr "更多網絡……" #: ../data/ui/right_menu.ui.h:1 msgid "Airplane Mode" msgstr "飛行模å¼" #: ../data/ui/right_menu.ui.h:2 msgid "unset airplane mode" msgstr "åœç”¨é£›è¡Œæ¨¡å¼" #: ../data/ui/right_menu.ui.h:3 msgid "set airplane mode" msgstr "開啟飛行模å¼" #: ../data/ui/right_menu.ui.h:4 msgid "Share connection" msgstr "共享連線" #: ../data/ui/right_menu.ui.h:5 msgid "Share your connection (tethering)" msgstr "共享你的連線（tethering）" #: ../data/ui/right_menu.ui.h:6 msgid "Quit ConnMan-UI" msgstr "離開 ConnMan-UI" #: ../data/ui/settings.ui.h:1 msgid "Autoconnect" msgstr "自動連線" #: ../data/ui/settings.ui.h:2 msgid "Favorite" msgstr "我的最愛" #: ../data/ui/settings.ui.h:3 msgid "Method: " msgstr "æ–¹å¼ï¼š" #: ../data/ui/settings.ui.h:4 msgid "DHCP" msgstr "DHCP" #: ../data/ui/settings.ui.h:5 msgid "Manual" msgstr "手動" #: ../data/ui/settings.ui.h:6 msgid "Off" msgstr "åœç”¨" #: ../data/ui/settings.ui.h:7 msgid "Address:" msgstr "ä½å€ï¼š" #: ../data/ui/settings.ui.h:8 msgid "Netmask:" msgstr "網絡é®ç½©ï¼š" #: ../data/ui/settings.ui.h:9 msgid "Gateway:" msgstr "é–˜é“：" #: ../data/ui/settings.ui.h:10 msgid "IPv4 Settings" msgstr "IPv4 設定" #: ../data/ui/settings.ui.h:11 msgid "Auto" msgstr "自動" #: ../data/ui/settings.ui.h:12 msgid "Prefix length:" msgstr "å‰ç½®é•·åº¦ï¼š" #: ../data/ui/settings.ui.h:13 msgid "Privacy: " msgstr "ç§éš±ï¼š" #: ../data/ui/settings.ui.h:14 msgid "Prefered" msgstr "å好" #: ../data/ui/settings.ui.h:15 msgid "Enabled" msgstr "已啟用" #: ../data/ui/settings.ui.h:16 msgid "Disabled" msgstr "å·²åœç”¨" #: ../data/ui/settings.ui.h:17 msgid "IPv6 Settings" msgstr "IPv6 設定" #: ../data/ui/settings.ui.h:18 msgid "Name servers" msgstr "å稱伺æœå™¨" #: ../data/ui/settings.ui.h:19 msgid "In use:" msgstr "使用中：" #: ../data/ui/settings.ui.h:20 msgid "Configuration:" msgstr "設定：" #: ../data/ui/settings.ui.h:21 msgid "One or multiple IPs separated by ';'" msgstr "一個或多個以「;ã€åˆ†éš”çš„ IP" #: ../data/ui/settings.ui.h:22 msgid "Domains" msgstr "網域" #: ../data/ui/settings.ui.h:23 msgid "One ore many domains separated by ';'" msgstr "一個或多個以「;ã€åˆ†éš”的網域" #: ../data/ui/settings.ui.h:24 msgid "DNS Settings" msgstr "DNS 設定" #: ../data/ui/settings.ui.h:25 msgid "Method:" msgstr "æ–¹å¼ï¼š" #: ../data/ui/settings.ui.h:26 msgid "Direct" msgstr "直接" #: ../data/ui/settings.ui.h:27 msgid "URL:" msgstr "URL：" #: ../data/ui/settings.ui.h:28 msgid "Servers:" msgstr "伺æœå™¨ï¼š" #: ../data/ui/settings.ui.h:29 msgid "Excludes:" msgstr "排除：" #: ../data/ui/settings.ui.h:30 msgid "Proxy Settings" msgstr "代ç†ä¼ºæœå™¨è¨­å®šï¼š" #: ../data/ui/settings.ui.h:31 msgid "One or many IPs/hostnames separated by ';'" msgstr "一個或多個以「;ã€åˆ†éš”çš„ IPï¼ä¸»æ©Ÿå稱" #: ../data/ui/settings.ui.h:32 msgid "Time servers Settings" msgstr "時間伺æœå™¨è¨­å®š" #: ../data/ui/settings.ui.h:33 msgid "Interface: " msgstr "ç•Œé¢ï¼š" #: ../data/ui/settings.ui.h:34 msgid "Address: " msgstr "ä½å€ï¼š" #: ../data/ui/settings.ui.h:35 msgid " MTU: " msgstr " MTU：" #: ../data/ui/settings.ui.h:36 msgid " Speed: " msgstr " 速度：" #: ../data/ui/settings.ui.h:37 msgid " Duplex: " msgstr " 雙工：" #: ../data/ui/settings.ui.h:38 msgid "Ethernet information" msgstr " 以太網設定" #: ../data/ui/settings.ui.h:39 msgid "Host: " msgstr "主機：" #: ../data/ui/settings.ui.h:40 msgid "Domain: " msgstr "網域：" #: ../data/ui/settings.ui.h:41 msgid " Name: " msgstr " å稱：" #: ../data/ui/settings.ui.h:42 msgid " Type: " msgstr " 類型：" #: ../data/ui/settings.ui.h:43 msgid "VPN provider information" msgstr "VPN 供應者資料" #: ../src/agent_dialogs.c:107 #, c-format msgid "" "Previous Passphrase:\n" "%s" msgstr "" "å‰ä¸€å€‹å¯†ç¢¼ï¼š\n" "%s" #: ../src/gtktechnology.c:268 msgid "" "Left click to enable/disable\n" "Right click to set tethering information" msgstr "" "按左éµå•Ÿç”¨ï¼åœç”¨\n" "按å³éµè¨­å®š tethering 資料" #: ../src/gtktechnology.c:272 msgid "Left to enable/disable" msgstr "按左éµå•Ÿç”¨ï¼åœç”¨" #: ../src/theme.c:33 msgid "Tethering" msgstr "Tethering" #: ../src/theme.c:45 msgid "Ethernet" msgstr "以太網" #: ../src/theme.c:49 msgid "Cellular" msgstr "æµå‹•ç¶²çµ¡" #: ../src/theme.c:68 msgid "Very good signal" msgstr "訊號éžå¸¸è‰¯å¥½" #: ../src/theme.c:72 msgid "Good signal" msgstr "訊號良好" #: ../src/theme.c:76 msgid "Low signal" msgstr "訊號微弱" #: ../src/theme.c:80 msgid "Very low signal" msgstr "訊號éžå¸¸å¾®å¼±" #: ../src/theme.c:102 msgid "Connman is not running" msgstr "未有執行 Connman" #: ../src/theme.c:107 msgid "Connected" msgstr "已連線" #: ../src/theme.c:112 msgid "Online" msgstr "線上" #: ../src/theme.c:117 msgid "Disconnected" msgstr "未連線" connman-ui-0_20150622+dfsg.orig/po/de.po0000644000175000017500000001571312541725135016132 0ustar nicknick# German translation for connman-ui. # Copyright (C) 2015 Benedikt Sauer # This file is distributed under the same license as the connman-ui package. # Benedikt Sauer , 2015. # msgid "" msgstr "" "Project-Id-Version: connman-ui\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2015-04-10 13:50+0200\n" "PO-Revision-Date: 2015-04-10 14:03+0100\n" "Last-Translator: \n" "Language-Team: Benedikt Sauer \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 1.5.5\n" "Language: de\n" #: ../data/ui/agent.ui.h:1 msgid "Retry" msgstr "Wiederholen" #: ../data/ui/agent.ui.h:2 msgid " Error " msgstr " Fehler" #: ../data/ui/agent.ui.h:3 msgid "Network " msgstr "Das Netz " #: ../data/ui/agent.ui.h:4 msgid "requires information to get connected" msgstr "benötigt weitere Informationen zum verbinden" #: ../data/ui/agent.ui.h:5 msgid "Name:" msgstr "Name:" #: ../data/ui/agent.ui.h:6 msgid "Identity:" msgstr "Identität:" #: ../data/ui/agent.ui.h:7 msgid "Passphrase:" msgstr "Passphrase:" #: ../data/ui/agent.ui.h:8 msgid "minimum 8 characters" msgstr "mindestens 8 Zeichen" #: ../data/ui/agent.ui.h:9 msgid "Previous Passphrase:" msgstr "Vorige Passphrase:" #: ../data/ui/agent.ui.h:10 msgid "You are probably trying to connect to a Hotspot." msgstr "Sie versuchen vermutlich auf einen Hotspot zu verbinden." #: ../data/ui/agent.ui.h:11 msgid "" " Login is required to get\n" "plain access to the network" msgstr " " #: ../data/ui/agent.ui.h:13 msgid "Username: " msgstr "Nutzername:" #: ../data/ui/agent.ui.h:14 msgid "Password: " msgstr "Passwort:" #: ../data/ui/agent.ui.h:15 msgid "Shared WiFi connection information" msgstr "Gemeinsame WiFi-Verbindungsdaten" #: ../data/ui/agent.ui.h:16 msgid "SSID: " msgstr "SSID:" #: ../data/ui/agent.ui.h:17 msgid "Passphrase: " msgstr "Passphrase:" #: ../data/ui/left_menu.ui.h:1 msgid "Available networks" msgstr "Verfügbare Netze" #: ../data/ui/left_menu.ui.h:2 msgid "Scanning..." msgstr "Suche…" #: ../data/ui/left_menu.ui.h:3 msgid "More networks ..." msgstr "Weitere Netze…" #: ../data/ui/right_menu.ui.h:1 msgid "Airplane Mode" msgstr "Flugmodus" #: ../data/ui/right_menu.ui.h:2 msgid "unset airplane mode" msgstr "Flugmodus deaktivieren" #: ../data/ui/right_menu.ui.h:3 msgid "set airplane mode" msgstr "Flugmodus aktivieren" #: ../data/ui/right_menu.ui.h:4 msgid "Share connection" msgstr "Verbindung freigeben" #: ../data/ui/right_menu.ui.h:5 msgid "Share your connection (tethering)" msgstr "Verbindung freigeben (tethering)" #: ../data/ui/right_menu.ui.h:6 msgid "Quit ConnMan-UI" msgstr "Beenden" #: ../data/ui/settings.ui.h:1 msgid "Autoconnect" msgstr "Automatisch verbinden" #: ../data/ui/settings.ui.h:2 msgid "Favorite" msgstr "Favorit" #: ../data/ui/settings.ui.h:3 msgid "Method: " msgstr "Verfahren:" #: ../data/ui/settings.ui.h:4 msgid "DHCP" msgstr "DHCP" #: ../data/ui/settings.ui.h:5 msgid "Manual" msgstr "Manuell" #: ../data/ui/settings.ui.h:6 msgid "Off" msgstr "Aus" #: ../data/ui/settings.ui.h:7 msgid "Address:" msgstr "Adresse:" #: ../data/ui/settings.ui.h:8 msgid "Netmask:" msgstr "Subnetzmaske:" #: ../data/ui/settings.ui.h:9 msgid "Gateway:" msgstr "Gateway:" #: ../data/ui/settings.ui.h:10 msgid "IPv4 Settings" msgstr "IPv4-Einstellungen" #: ../data/ui/settings.ui.h:11 msgid "Auto" msgstr "Automatisch" #: ../data/ui/settings.ui.h:12 msgid "Prefix length:" msgstr "Präfixlänge:" #: ../data/ui/settings.ui.h:13 msgid "Privacy: " msgstr "Sicherheit:" #: ../data/ui/settings.ui.h:14 msgid "Prefered" msgstr "Bevorzugt" #: ../data/ui/settings.ui.h:15 msgid "Enabled" msgstr "Aktiviert" #: ../data/ui/settings.ui.h:16 msgid "Disabled" msgstr "Deaktiviert" #: ../data/ui/settings.ui.h:17 msgid "IPv6 Settings" msgstr "IPv6-Einstellungen" #: ../data/ui/settings.ui.h:18 msgid "Name servers" msgstr "Nameserver" #: ../data/ui/settings.ui.h:19 msgid "In use:" msgstr "Verwendet:" #: ../data/ui/settings.ui.h:20 msgid "Configuration:" msgstr "Konfiguration:" #: ../data/ui/settings.ui.h:21 msgid "One or multiple IPs separated by ';'" msgstr "Eine oder mehrere IP-Adressen, getrennt durch ';'" #: ../data/ui/settings.ui.h:22 msgid "Domains" msgstr "Domänen" #: ../data/ui/settings.ui.h:23 msgid "One ore many domains separated by ';'" msgstr "Eine oder mehrere Domänen, getrennt durch ';'" #: ../data/ui/settings.ui.h:24 msgid "DNS Settings" msgstr "DNS-Einstellungen" #: ../data/ui/settings.ui.h:25 msgid "Method:" msgstr "Verfahren:" #: ../data/ui/settings.ui.h:26 msgid "Direct" msgstr "Direkt" #: ../data/ui/settings.ui.h:27 msgid "URL:" msgstr "URL:" #: ../data/ui/settings.ui.h:28 msgid "Servers:" msgstr "Server:" #: ../data/ui/settings.ui.h:29 msgid "Excludes:" msgstr "Ausgenommen:" #: ../data/ui/settings.ui.h:30 msgid "Proxy Settings" msgstr "Proxy-Einstellungen:" #: ../data/ui/settings.ui.h:31 msgid "One or many IPs/hostnames separated by ';'" msgstr "Ein oder mehrere Hostnamen/IP-Adressen, getrennt durch ';'" #: ../data/ui/settings.ui.h:32 msgid "Time servers Settings" msgstr "Zeitserver-Einstellungen" #: ../data/ui/settings.ui.h:33 msgid "Interface: " msgstr "Schnittstelle:" #: ../data/ui/settings.ui.h:34 msgid "Address: " msgstr "Adresse:" #: ../data/ui/settings.ui.h:35 msgid " MTU: " msgstr " MTU:" #: ../data/ui/settings.ui.h:36 msgid " Speed: " msgstr " Geschwindigkeit:" #: ../data/ui/settings.ui.h:37 msgid " Duplex: " msgstr " Duplex:" #: ../data/ui/settings.ui.h:38 msgid "Ethernet information" msgstr "Ethernet-Informationen" #: ../data/ui/settings.ui.h:39 msgid "Host: " msgstr "Hostname:" #: ../data/ui/settings.ui.h:40 msgid "Domain: " msgstr "Domäne:" #: ../data/ui/settings.ui.h:41 msgid " Name: " msgstr " Name:" #: ../data/ui/settings.ui.h:42 msgid " Type: " msgstr " Typ:" #: ../data/ui/settings.ui.h:43 msgid "VPN provider information" msgstr "VPN-Informationen" #: ../src/agent_dialogs.c:107 #, c-format msgid "" "Previous Passphrase:\n" "%s" msgstr "" "Vorige Passphrase:\n" "%s" #: ../src/gtktechnology.c:268 msgid "" "Left click to enable/disable\n" "Right click to set tethering information" msgstr "" "Linksklicken um zu (de)aktivieren\n" "Rechtsklicken um Tethering-Informationen anzuzeigen" #: ../src/gtktechnology.c:272 msgid "Left to enable/disable" msgstr "Linksklicken zum (de)aktivieren" #: ../src/theme.c:33 msgid "Tethering" msgstr "Tethering" #: ../src/theme.c:45 msgid "Ethernet" msgstr "Ethernet" #: ../src/theme.c:49 msgid "Cellular" msgstr "Mobil" #: ../src/theme.c:68 msgid "Very good signal" msgstr "Sehr gut" #: ../src/theme.c:72 msgid "Good signal" msgstr "Gut" #: ../src/theme.c:76 msgid "Low signal" msgstr "Schwach" #: ../src/theme.c:80 msgid "Very low signal" msgstr "Sehr schwach" #: ../src/theme.c:102 msgid "Connman is not running" msgstr "Connman läuft nicht" #: ../src/theme.c:107 msgid "Connected" msgstr "Verbunden" #: ../src/theme.c:112 msgid "Online" msgstr "Online" #: ../src/theme.c:117 msgid "Disconnected" msgstr "Getrennt" connman-ui-0_20150622+dfsg.orig/po/LINGUAS0000644000175000017500000000003312541725135016214 0ustar nicknickes fr de zh_CN zh_TW zh_HK connman-ui-0_20150622+dfsg.orig/po/POTFILES.in0000644000175000017500000000066212541725135016754 0ustar nicknick[encoding: UTF-8] [type: gettext/glade] data/ui/agent.ui [type: gettext/glade] data/ui/left_menu.ui [type: gettext/glade] data/ui/right_menu.ui [type: gettext/glade] data/ui/settings.ui [type: gettext/glade] data/ui/tray.ui src/agent_dialogs.c src/connman-ui-gtk.h src/gtkservice.c src/gtkservice.h src/gtktechnology.c src/gtktechnology.h src/left-menu.c src/main.c src/right-menu.c src/settings.c src/theme.c src/tray.c src/utils.c connman-ui-0_20150622+dfsg.orig/po/zh_TW.po0000644000175000017500000001567312541725135016602 0ustar nicknick# Traditional Chinese (Taiwan) translation for connman-ui. # Copyright (C) 2015 Timothy Lee # This file is distributed under the same license as the connman-ui package. # Timothy Lee , 2015. # msgid "" msgstr "" "Project-Id-Version: connman-ui\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2015-04-11 11:21+0800\n" "PO-Revision-Date: 2015-04-11 11:21+0800\n" "Last-Translator: \n" "Language-Team: Timothy Lee \n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 1.5.5\n" "Language: zh-TW\n" #: ../data/ui/agent.ui.h:1 msgid "Retry" msgstr "é‡è©¦" #: ../data/ui/agent.ui.h:2 msgid " Error " msgstr " 錯誤 " #: ../data/ui/agent.ui.h:3 msgid "Network " msgstr "網絡 " #: ../data/ui/agent.ui.h:4 msgid "requires information to get connected" msgstr "連線須æ供資料" #: ../data/ui/agent.ui.h:5 msgid "Name:" msgstr "å稱：" #: ../data/ui/agent.ui.h:6 msgid "Identity:" msgstr "身份：" #: ../data/ui/agent.ui.h:7 msgid "Passphrase:" msgstr "Passphrase:" #: ../data/ui/agent.ui.h:8 msgid "minimum 8 characters" msgstr "最少 8 個字元" #: ../data/ui/agent.ui.h:9 msgid "Previous Passphrase:" msgstr "å‰ä¸€å€‹å¯†ç¢¼ï¼š" #: ../data/ui/agent.ui.h:10 msgid "You are probably trying to connect to a Hotspot." msgstr "你應該在嘗試連線至一個熱點。" #: ../data/ui/agent.ui.h:11 msgid "" " Login is required to get\n" "plain access to the network" msgstr "" " 你必須登入\n" "æ‰èƒ½å­˜å–網絡" #: ../data/ui/agent.ui.h:13 msgid "Username: " msgstr "用戶å稱：" #: ../data/ui/agent.ui.h:14 msgid "Password: " msgstr "密碼：" #: ../data/ui/agent.ui.h:15 msgid "Shared WiFi connection information" msgstr "共享 WiFi 的連線資料" #: ../data/ui/agent.ui.h:16 msgid "SSID: " msgstr "SSID：" #: ../data/ui/agent.ui.h:17 msgid "Passphrase: " msgstr "密碼：" #: ../data/ui/left_menu.ui.h:1 msgid "Available networks" msgstr "å¯ç”¨ç¶²çµ¡" #: ../data/ui/left_menu.ui.h:2 msgid "Scanning..." msgstr "掃æ中……" #: ../data/ui/left_menu.ui.h:3 msgid "More networks ..." msgstr "更多網絡……" #: ../data/ui/right_menu.ui.h:1 msgid "Airplane Mode" msgstr "飛行模å¼" #: ../data/ui/right_menu.ui.h:2 msgid "unset airplane mode" msgstr "åœç”¨é£›è¡Œæ¨¡å¼" #: ../data/ui/right_menu.ui.h:3 msgid "set airplane mode" msgstr "開啟飛行模å¼" #: ../data/ui/right_menu.ui.h:4 msgid "Share connection" msgstr "共享連線" #: ../data/ui/right_menu.ui.h:5 msgid "Share your connection (tethering)" msgstr "共享你的連線（tethering）" #: ../data/ui/right_menu.ui.h:6 msgid "Quit ConnMan-UI" msgstr "離開 ConnMan-UI" #: ../data/ui/settings.ui.h:1 msgid "Autoconnect" msgstr "自動連線" #: ../data/ui/settings.ui.h:2 msgid "Favorite" msgstr "我的最愛" #: ../data/ui/settings.ui.h:3 msgid "Method: " msgstr "æ–¹å¼ï¼š" #: ../data/ui/settings.ui.h:4 msgid "DHCP" msgstr "DHCP" #: ../data/ui/settings.ui.h:5 msgid "Manual" msgstr "手動" #: ../data/ui/settings.ui.h:6 msgid "Off" msgstr "åœç”¨" #: ../data/ui/settings.ui.h:7 msgid "Address:" msgstr "ä½å€ï¼š" #: ../data/ui/settings.ui.h:8 msgid "Netmask:" msgstr "網絡é®ç½©ï¼š" #: ../data/ui/settings.ui.h:9 msgid "Gateway:" msgstr "é–˜é“：" #: ../data/ui/settings.ui.h:10 msgid "IPv4 Settings" msgstr "IPv4 設定" #: ../data/ui/settings.ui.h:11 msgid "Auto" msgstr "自動" #: ../data/ui/settings.ui.h:12 msgid "Prefix length:" msgstr "å‰ç½®é•·åº¦ï¼š" #: ../data/ui/settings.ui.h:13 msgid "Privacy: " msgstr "ç§éš±ï¼š" #: ../data/ui/settings.ui.h:14 msgid "Prefered" msgstr "å好" #: ../data/ui/settings.ui.h:15 msgid "Enabled" msgstr "已啟用" #: ../data/ui/settings.ui.h:16 msgid "Disabled" msgstr "å·²åœç”¨" #: ../data/ui/settings.ui.h:17 msgid "IPv6 Settings" msgstr "IPv6 設定" #: ../data/ui/settings.ui.h:18 msgid "Name servers" msgstr "å稱伺æœå™¨" #: ../data/ui/settings.ui.h:19 msgid "In use:" msgstr "使用中：" #: ../data/ui/settings.ui.h:20 msgid "Configuration:" msgstr "設定：" #: ../data/ui/settings.ui.h:21 msgid "One or multiple IPs separated by ';'" msgstr "一個或多個以「;ã€åˆ†éš”çš„ IP" #: ../data/ui/settings.ui.h:22 msgid "Domains" msgstr "網域" #: ../data/ui/settings.ui.h:23 msgid "One ore many domains separated by ';'" msgstr "一個或多個以「;ã€åˆ†éš”的網域" #: ../data/ui/settings.ui.h:24 msgid "DNS Settings" msgstr "DNS 設定" #: ../data/ui/settings.ui.h:25 msgid "Method:" msgstr "æ–¹å¼ï¼š" #: ../data/ui/settings.ui.h:26 msgid "Direct" msgstr "直接" #: ../data/ui/settings.ui.h:27 msgid "URL:" msgstr "URL：" #: ../data/ui/settings.ui.h:28 msgid "Servers:" msgstr "伺æœå™¨ï¼š" #: ../data/ui/settings.ui.h:29 msgid "Excludes:" msgstr "排除：" #: ../data/ui/settings.ui.h:30 msgid "Proxy Settings" msgstr "代ç†ä¼ºæœå™¨è¨­å®šï¼š" #: ../data/ui/settings.ui.h:31 msgid "One or many IPs/hostnames separated by ';'" msgstr "一個或多個以「;ã€åˆ†éš”çš„ IPï¼ä¸»æ©Ÿå稱" #: ../data/ui/settings.ui.h:32 msgid "Time servers Settings" msgstr "時間伺æœå™¨è¨­å®š" #: ../data/ui/settings.ui.h:33 msgid "Interface: " msgstr "ç•Œé¢ï¼š" #: ../data/ui/settings.ui.h:34 msgid "Address: " msgstr "ä½å€ï¼š" #: ../data/ui/settings.ui.h:35 msgid " MTU: " msgstr " MTU：" #: ../data/ui/settings.ui.h:36 msgid " Speed: " msgstr " 速度：" #: ../data/ui/settings.ui.h:37 msgid " Duplex: " msgstr " 雙工：" #: ../data/ui/settings.ui.h:38 msgid "Ethernet information" msgstr " 以太網設定" #: ../data/ui/settings.ui.h:39 msgid "Host: " msgstr "主機：" #: ../data/ui/settings.ui.h:40 msgid "Domain: " msgstr "網域：" #: ../data/ui/settings.ui.h:41 msgid " Name: " msgstr " å稱：" #: ../data/ui/settings.ui.h:42 msgid " Type: " msgstr " 類型：" #: ../data/ui/settings.ui.h:43 msgid "VPN provider information" msgstr "VPN 供應者資料" #: ../src/agent_dialogs.c:107 #, c-format msgid "" "Previous Passphrase:\n" "%s" msgstr "" "å‰ä¸€å€‹å¯†ç¢¼ï¼š\n" "%s" #: ../src/gtktechnology.c:268 msgid "" "Left click to enable/disable\n" "Right click to set tethering information" msgstr "" "按左éµå•Ÿç”¨ï¼åœç”¨\n" "按å³éµè¨­å®š tethering 資料" #: ../src/gtktechnology.c:272 msgid "Left to enable/disable" msgstr "按左éµå•Ÿç”¨ï¼åœç”¨" #: ../src/theme.c:33 msgid "Tethering" msgstr "Tethering" #: ../src/theme.c:45 msgid "Ethernet" msgstr "以太網" #: ../src/theme.c:49 msgid "Cellular" msgstr "æµå‹•ç¶²çµ¡" #: ../src/theme.c:68 msgid "Very good signal" msgstr "訊號éžå¸¸è‰¯å¥½" #: ../src/theme.c:72 msgid "Good signal" msgstr "訊號良好" #: ../src/theme.c:76 msgid "Low signal" msgstr "訊號微弱" #: ../src/theme.c:80 msgid "Very low signal" msgstr "訊號éžå¸¸å¾®å¼±" #: ../src/theme.c:102 msgid "Connman is not running" msgstr "未有執行 Connman" #: ../src/theme.c:107 msgid "Connected" msgstr "已連線" #: ../src/theme.c:112 msgid "Online" msgstr "線上" #: ../src/theme.c:117 msgid "Disconnected" msgstr "未連線" connman-ui-0_20150622+dfsg.orig/include/0000755000175000017500000000000012541725135016200 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/include/version.h.in0000644000175000017500000000172212541725135020445 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef __CONNMAN_UI_VERSION_H #define __CONNMAN_UI_VERSION_H #ifdef __cplusplus extern "C" { #endif #define CONNMAN_UI_VERSION "@VERSION@" #ifdef __cplusplus } #endif #endif /* __CONNMAN_UI_VERSION_H */ connman-ui-0_20150622+dfsg.orig/TODO0000644000175000017500000000052012541725135015242 0ustar nicknick- Support brand new ConnMan's vpnd agent API. - Translations (German, Italian ...) - Redraw the UI layouts (mainly settings.ui, which is currently lame) - Propose own icon set (svg based) - Support Agent API's RequestBrowser() method properly - Support moving down/up connected services (MoveBefore(), MoveAfter Service API's methods) connman-ui-0_20150622+dfsg.orig/valgrind.suppressions0000644000175000017500000001230012541725135021056 0ustar nicknick# # Valgrind suppression file for Gtk+ 2.12 # # Format specification: # http://valgrind.org/docs/manual/manual-core.html#manual-core.suppress # # # glibc Ubuntu Edgy # { libc: getpwnam_r Memcheck:Addr4 obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/tls/i686/cmov/libc-*.so obj:/lib/ld-*.so fun:__libc_dlopen_mode fun:__nss_lookup_function obj:/lib/tls/i686/cmov/libc-*.so fun:__nss_passwd_lookup fun:getpwnam_r fun:g_get_any_init_do fun:g_get_home_dir fun:gtk_rc_add_initial_default_files fun:_gtk_rc_init fun:post_parse_hook fun:g_option_context_parse fun:gtk_parse_args fun:gtk_init_check fun:gtk_init } { libc: getpwnam_r Memcheck:Addr4 obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/tls/i686/cmov/libc-*.so obj:/lib/ld-*.so fun:__libc_dlopen_mode fun:__nss_lookup_function obj:/lib/tls/i686/cmov/libc-*.so fun:__nss_passwd_lookup fun:getpwnam_r fun:g_get_any_init_do fun:g_get_home_dir fun:gtk_rc_add_initial_default_files fun:_gtk_rc_init fun:post_parse_hook fun:g_option_context_parse fun:gtk_parse_args fun:gtk_init_check fun:gtk_init } { libc: getpwnam_r Memcheck:Addr4 obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/tls/i686/cmov/libc-*.so obj:/lib/ld-*.so fun:__libc_dlopen_mode fun:__nss_lookup_function fun:__nss_next fun:getpwnam_r fun:g_get_any_init_do fun:g_get_home_dir fun:gtk_rc_add_initial_default_files fun:_gtk_rc_init fun:post_parse_hook fun:g_option_context_parse fun:gtk_parse_args fun:gtk_init_check fun:gtk_init } { libc: getpwnam_r Memcheck:Addr4 obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/ld-*.so obj:/lib/tls/i686/cmov/libc-*.so obj:/lib/ld-*.so fun:__libc_dlopen_mode fun:__nss_lookup_function fun:__nss_next fun:getpwnam_r fun:g_get_any_init_do fun:g_get_home_dir fun:gtk_rc_add_initial_default_files fun:_gtk_rc_init fun:post_parse_hook fun:g_option_context_parse fun:gtk_parse_args fun:gtk_init_check fun:gtk_init } # # glibc Ubuntu feisty # { getpwnam_r Memcheck:Leak fun:malloc obj:/lib/libc-2.5.so fun:__nss_database_lookup obj:* obj:* fun:getpwnam_r } # # X # { XSupportsLocale Memcheck:Addr4 obj:/lib/ld-*.so obj:/lib/tls/i686/cmov/libdl-*.so obj:/lib/ld-*.so obj:/lib/tls/i686/cmov/libdl-*.so fun:dlopen obj:/usr/lib/libX11.so.6.2.0 fun:_XlcDynamicLoad fun:_XOpenLC fun:_XlcCurrentLC fun:XSupportsLocale fun:_gdk_x11_initialize_locale fun:_gdk_windowing_init fun:gdk_pre_parse_libgtk_only fun:pre_parse_hook fun:g_option_context_parse fun:gtk_parse_args fun:gtk_init_check fun:gtk_init fun:main } { Xcursor Memcheck:Leak fun:malloc obj:/usr/lib/libXcursor.so.1.0.2 obj:/usr/lib/libXcursor.so.1.0.2 fun:XcursorXcFileLoadImages fun:XcursorFileLoadImages fun:XcursorLibraryLoadImages fun:XcursorShapeLoadImages fun:XcursorTryShapeCursor fun:XCreateGlyphCursor fun:XCreateFontCursor fun:gdk_cursor_new_for_display } { XcursorGetTheme Memcheck:Leak fun:malloc fun:/usr/lib/libX11.so.6.2.0 fun:/usr/lib/libX11.so.6.2.0 fun:XrmGetStringDatabase fun:XGetDefault fun:_XcursorGetDisplayInfo fun:XcursorGetTheme } { XOpenDisplay Memcheck:Leak fun:calloc fun:XOpenDisplay } { XOpenDisplay Memcheck:Leak fun:malloc fun:XOpenDisplay } # # fontconfig # { fontconfig Memcheck:Leak fun:realloc fun:FcPatternObjectInsertElt fun:FcPatternObjectAddWithBinding } { pango_fc_font_map_load_fontset Memcheck:Leak fun:malloc fun:FcLangSetCreate fun:FcLangSetCopy fun:FcValueSave fun:FcPatternObjectAddWithBinding fun:FcPatternObjectAdd fun:FcFontRenderPrepare fun:pango_fc_font_map_load_fontset fun:pango_font_map_load_fontset } { pango_font_map_load_fontset Memcheck:Leak fun:malloc fun:FcPatternObjectAddWithBinding fun:FcPatternObjectAdd fun:FcFontRenderPrepare fun:pango_fc_font_map_load_fontset fun:pango_font_map_load_fontset } { pango_fc_font_map_load_fontset Memcheck:Leak fun:malloc fun:FcStrStaticName fun:FcPatternObjectAddWithBinding fun:FcPatternObjectAdd fun:FcFontRenderPrepare fun:pango_fc_font_map_load_fontset } { pango_fc_font_map_list_families Memcheck:Leak fun:malloc fun:FcStrStaticName fun:FcPatternObjectAddWithBinding fun:FcPatternAdd fun:FcFontSetList fun:FcFontList fun:pango_fc_font_map_list_families } # # freetype # { freetype FT_Init_FreeType Memcheck:Leak fun:malloc obj:/usr/lib/libfreetype.so.6.3.10 fun:ft_mem_qalloc fun:ft_mem_alloc fun:FT_New_Library fun:FT_Init_FreeType } # # glib # { glib g_rand_new Memcheck:Leak fun:calloc fun:g_malloc0 fun:g_rand_new_with_seed_array fun:g_rand_new fun:g_random_int } connman-ui-0_20150622+dfsg.orig/ABOUT-NLS0000644000175000017500000026713312541725135016020 0ustar nicknick1 Notes on the Free Translation Project *************************************** Free software is going international! The Free Translation Project is a way to get maintainers of free software, translators, and users all together, so that free software will gradually become able to speak many languages. A few packages already provide translations for their messages. If you found this `ABOUT-NLS' file inside a distribution, you may assume that the distributed package does use GNU `gettext' internally, itself available at your nearest GNU archive site. But you do _not_ need to install GNU `gettext' prior to configuring, installing or using this package with messages translated. Installers will find here some useful hints. These notes also explain how users should proceed for getting the programs to use the available translations. They tell how people wanting to contribute and work on translations can contact the appropriate team. 1.1 INSTALL Matters =================== Some packages are "localizable" when properly installed; the programs they contain can be made to speak your own native language. Most such packages use GNU `gettext'. Other packages have their own ways to internationalization, predating GNU `gettext'. By default, this package will be installed to allow translation of messages. It will automatically detect whether the system already provides the GNU `gettext' functions. Installers may use special options at configuration time for changing the default behaviour. The command: ./configure --disable-nls will _totally_ disable translation of messages. When you already have GNU `gettext' installed on your system and run configure without an option for your new package, `configure' will probably detect the previously built and installed `libintl' library and will decide to use it. If not, you may have to to use the `--with-libintl-prefix' option to tell `configure' where to look for it. Internationalized packages usually have many `po/LL.po' files, where LL gives an ISO 639 two-letter code identifying the language. Unless translations have been forbidden at `configure' time by using the `--disable-nls' switch, all available translations are installed together with the package. However, the environment variable `LINGUAS' may be set, prior to configuration, to limit the installed set. `LINGUAS' should then contain a space separated list of two-letter codes, stating which languages are allowed. 1.2 Using This Package ====================== As a user, if your language has been installed for this package, you only have to set the `LANG' environment variable to the appropriate `LL_CC' combination. If you happen to have the `LC_ALL' or some other `LC_xxx' environment variables set, you should unset them before setting `LANG', otherwise the setting of `LANG' will not have the desired effect. Here `LL' is an ISO 639 two-letter language code, and `CC' is an ISO 3166 two-letter country code. For example, let's suppose that you speak German and live in Germany. At the shell prompt, merely execute `setenv LANG de_DE' (in `csh'), `export LANG; LANG=de_DE' (in `sh') or `export LANG=de_DE' (in `bash'). This can be done from your `.login' or `.profile' file, once and for all. You might think that the country code specification is redundant. But in fact, some languages have dialects in different countries. For example, `de_AT' is used for Austria, and `pt_BR' for Brazil. The country code serves to distinguish the dialects. The locale naming convention of `LL_CC', with `LL' denoting the language and `CC' denoting the country, is the one use on systems based on GNU libc. On other systems, some variations of this scheme are used, such as `LL' or `LL_CC.ENCODING'. You can get the list of locales supported by your system for your language by running the command `locale -a | grep '^LL''. Not all programs have translations for all languages. By default, an English message is shown in place of a nonexistent translation. If you understand other languages, you can set up a priority list of languages. This is done through a different environment variable, called `LANGUAGE'. GNU `gettext' gives preference to `LANGUAGE' over `LANG' for the purpose of message handling, but you still need to have `LANG' set to the primary language; this is required by other parts of the system libraries. For example, some Swedish users who would rather read translations in German than English for when Swedish is not available, set `LANGUAGE' to `sv:de' while leaving `LANG' to `sv_SE'. Special advice for Norwegian users: The language code for Norwegian bokma*l changed from `no' to `nb' recently (in 2003). During the transition period, while some message catalogs for this language are installed under `nb' and some older ones under `no', it's recommended for Norwegian users to set `LANGUAGE' to `nb:no' so that both newer and older translations are used. In the `LANGUAGE' environment variable, but not in the `LANG' environment variable, `LL_CC' combinations can be abbreviated as `LL' to denote the language's main dialect. For example, `de' is equivalent to `de_DE' (German as spoken in Germany), and `pt' to `pt_PT' (Portuguese as spoken in Portugal) in this context. 1.3 Translating Teams ===================== For the Free Translation Project to be a success, we need interested people who like their own language and write it well, and who are also able to synergize with other translators speaking the same language. Each translation team has its own mailing list. The up-to-date list of teams can be found at the Free Translation Project's homepage, `http://translationproject.org/', in the "Teams" area. If you'd like to volunteer to _work_ at translating messages, you should become a member of the translating team for your own language. The subscribing address is _not_ the same as the list itself, it has `-request' appended. For example, speakers of Swedish can send a message to `sv-request@li.org', having this message body: subscribe Keep in mind that team members are expected to participate _actively_ in translations, or at solving translational difficulties, rather than merely lurking around. If your team does not exist yet and you want to start one, or if you are unsure about what to do or how to get started, please write to `coordinator@translationproject.org' to reach the coordinator for all translator teams. The English team is special. It works at improving and uniformizing the terminology in use. Proven linguistic skills are praised more than programming skills, here. 1.4 Available Packages ====================== Languages are not equally supported in all packages. The following matrix shows the current state of internationalization, as of June 2010. The matrix shows, in regard of each package, for which languages PO files have been submitted to translation coordination, with a translation percentage of at least 50%. Ready PO files af am an ar as ast az be be@latin bg bn_IN bs ca +--------------------------------------------------+ a2ps | [] [] | aegis | | ant-phone | | anubis | | aspell | [] [] | bash | | bfd | | bibshelf | [] | binutils | | bison | | bison-runtime | [] | bluez-pin | [] [] | bombono-dvd | | buzztard | | cflow | | clisp | | coreutils | [] [] | cpio | | cppi | | cpplib | [] | cryptsetup | | dfarc | | dialog | [] [] | dico | | diffutils | [] | dink | | doodle | | e2fsprogs | [] | enscript | [] | exif | | fetchmail | [] | findutils | [] | flex | [] | freedink | | gas | | gawk | [] [] | gcal | [] | gcc | | gettext-examples | [] [] [] [] | gettext-runtime | [] [] | gettext-tools | [] [] | gip | [] | gjay | | gliv | [] | glunarclock | [] [] | gnubiff | | gnucash | [] | gnuedu | | gnulib | | gnunet | | gnunet-gtk | | gnutls | | gold | | gpe-aerial | | gpe-beam | | gpe-bluetooth | | gpe-calendar | | gpe-clock | [] | gpe-conf | | gpe-contacts | | gpe-edit | | gpe-filemanager | | gpe-go | | gpe-login | | gpe-ownerinfo | [] | gpe-package | | gpe-sketchbook | | gpe-su | [] | gpe-taskmanager | [] | gpe-timesheet | [] | gpe-today | [] | gpe-todo | | gphoto2 | | gprof | [] | gpsdrive | | gramadoir | | grep | | grub | [] [] | gsasl | | gss | | gst-plugins-bad | [] | gst-plugins-base | [] | gst-plugins-good | [] | gst-plugins-ugly | [] | gstreamer | [] [] [] | gtick | | gtkam | [] | gtkorphan | [] | gtkspell | [] [] [] | gutenprint | | hello | [] | help2man | | hylafax | | idutils | | indent | [] [] | iso_15924 | | iso_3166 | [] [] [] [] [] [] [] | iso_3166_2 | | iso_4217 | | iso_639 | [] [] [] [] | iso_639_3 | | jwhois | | kbd | | keytouch | [] | keytouch-editor | | keytouch-keyboa... | [] | klavaro | [] | latrine | | ld | [] | leafpad | [] [] | libc | [] [] | libexif | () | libextractor | | libgnutls | | libgpewidget | | libgpg-error | | libgphoto2 | | libgphoto2_port | | libgsasl | | libiconv | [] | libidn | | lifelines | | liferea | [] [] | lilypond | | linkdr | [] | lordsawar | | lprng | | lynx | [] | m4 | | mailfromd | | mailutils | | make | | man-db | | man-db-manpages | | minicom | | mkisofs | | myserver | | nano | [] [] | opcodes | | parted | | pies | | popt | | psmisc | | pspp | [] | pwdutils | | radius | [] | recode | [] [] | rosegarden | | rpm | | rush | | sarg | | screem | | scrollkeeper | [] [] [] | sed | [] [] | sharutils | [] [] | shishi | | skencil | | solfege | | solfege-manual | | soundtracker | | sp | | sysstat | | tar | [] | texinfo | | tin | | unicode-han-tra... | | unicode-transla... | | util-linux-ng | [] | vice | | vmm | | vorbis-tools | | wastesedge | | wdiff | | wget | [] [] | wyslij-po | | xchat | [] [] [] [] | xdg-user-dirs | [] [] [] [] [] [] [] [] [] | xkeyboard-config | [] [] | +--------------------------------------------------+ af am an ar as ast az be be@latin bg bn_IN bs ca 6 0 1 2 3 19 1 10 3 28 3 1 38 crh cs da de el en en_GB en_ZA eo es et eu fa +-------------------------------------------------+ a2ps | [] [] [] [] [] [] [] | aegis | [] [] [] | ant-phone | [] () | anubis | [] [] | aspell | [] [] [] [] [] | bash | [] [] [] | bfd | [] | bibshelf | [] [] [] | binutils | [] | bison | [] [] | bison-runtime | [] [] [] [] | bluez-pin | [] [] [] [] [] [] | bombono-dvd | [] | buzztard | [] [] [] | cflow | [] [] | clisp | [] [] [] [] | coreutils | [] [] [] [] | cpio | | cppi | | cpplib | [] [] [] | cryptsetup | [] | dfarc | [] [] [] | dialog | [] [] [] [] [] | dico | | diffutils | [] [] [] [] [] [] | dink | [] [] [] | doodle | [] | e2fsprogs | [] [] [] | enscript | [] [] [] | exif | () [] [] | fetchmail | [] [] () [] [] [] | findutils | [] [] [] | flex | [] [] | freedink | [] [] [] | gas | [] | gawk | [] [] [] | gcal | [] | gcc | [] [] | gettext-examples | [] [] [] [] | gettext-runtime | [] [] [] [] | gettext-tools | [] [] [] | gip | [] [] [] [] | gjay | [] | gliv | [] [] [] | glunarclock | [] [] | gnubiff | () | gnucash | [] () () () () | gnuedu | [] [] | gnulib | [] [] | gnunet | | gnunet-gtk | [] | gnutls | [] [] | gold | [] | gpe-aerial | [] [] [] [] | gpe-beam | [] [] [] [] | gpe-bluetooth | [] [] | gpe-calendar | [] | gpe-clock | [] [] [] [] | gpe-conf | [] [] [] | gpe-contacts | [] [] [] | gpe-edit | [] [] | gpe-filemanager | [] [] [] | gpe-go | [] [] [] [] | gpe-login | [] [] | gpe-ownerinfo | [] [] [] [] | gpe-package | [] [] [] | gpe-sketchbook | [] [] [] [] | gpe-su | [] [] [] [] | gpe-taskmanager | [] [] [] [] | gpe-timesheet | [] [] [] [] | gpe-today | [] [] [] [] | gpe-todo | [] [] [] | gphoto2 | [] [] () [] [] [] | gprof | [] [] [] | gpsdrive | [] [] [] | gramadoir | [] [] [] | grep | [] | grub | [] [] | gsasl | [] | gss | | gst-plugins-bad | [] [] [] [] [] | gst-plugins-base | [] [] [] [] [] | gst-plugins-good | [] [] [] [] [] [] | gst-plugins-ugly | [] [] [] [] [] [] | gstreamer | [] [] [] [] [] | gtick | [] () [] | gtkam | [] [] () [] [] | gtkorphan | [] [] [] [] | gtkspell | [] [] [] [] [] [] [] | gutenprint | [] [] [] | hello | [] [] [] [] | help2man | [] | hylafax | [] [] | idutils | [] [] | indent | [] [] [] [] [] [] [] | iso_15924 | [] () [] [] | iso_3166 | [] [] [] [] () [] [] [] () | iso_3166_2 | () | iso_4217 | [] [] [] () [] [] | iso_639 | [] [] [] [] () [] [] | iso_639_3 | [] | jwhois | [] | kbd | [] [] [] [] [] | keytouch | [] [] | keytouch-editor | [] [] | keytouch-keyboa... | [] | klavaro | [] [] [] [] | latrine | [] () | ld | [] [] | leafpad | [] [] [] [] [] [] | libc | [] [] [] [] | libexif | [] [] () | libextractor | | libgnutls | [] | libgpewidget | [] [] | libgpg-error | [] [] | libgphoto2 | [] () | libgphoto2_port | [] () [] | libgsasl | | libiconv | [] [] [] [] [] | libidn | [] [] [] | lifelines | [] () | liferea | [] [] [] [] [] | lilypond | [] [] [] | linkdr | [] [] [] | lordsawar | [] | lprng | | lynx | [] [] [] [] | m4 | [] [] [] [] | mailfromd | | mailutils | [] | make | [] [] [] | man-db | | man-db-manpages | | minicom | [] [] [] [] | mkisofs | | myserver | | nano | [] [] [] | opcodes | [] [] | parted | [] [] | pies | | popt | [] [] [] [] [] | psmisc | [] [] [] | pspp | [] | pwdutils | [] | radius | [] | recode | [] [] [] [] [] [] | rosegarden | () () () | rpm | [] [] [] | rush | | sarg | | screem | | scrollkeeper | [] [] [] [] [] | sed | [] [] [] [] [] [] | sharutils | [] [] [] [] | shishi | | skencil | [] () [] | solfege | [] [] [] | solfege-manual | [] [] | soundtracker | [] [] [] | sp | [] | sysstat | [] [] [] | tar | [] [] [] [] | texinfo | [] [] [] | tin | [] [] | unicode-han-tra... | | unicode-transla... | | util-linux-ng | [] [] [] [] | vice | () () | vmm | [] | vorbis-tools | [] [] | wastesedge | [] | wdiff | [] [] | wget | [] [] [] | wyslij-po | | xchat | [] [] [] [] [] | xdg-user-dirs | [] [] [] [] [] [] [] [] [] | xkeyboard-config | [] [] [] [] [] [] | +-------------------------------------------------+ crh cs da de el en en_GB en_ZA eo es et eu fa 5 64 105 117 18 1 8 0 28 89 18 19 0 fi fr ga gl gu he hi hr hu hy id is it ja ka kn +----------------------------------------------------+ a2ps | [] [] [] [] | aegis | [] [] | ant-phone | [] [] | anubis | [] [] [] [] | aspell | [] [] [] [] | bash | [] [] [] [] | bfd | [] [] [] | bibshelf | [] [] [] [] [] | binutils | [] [] [] | bison | [] [] [] [] | bison-runtime | [] [] [] [] [] [] | bluez-pin | [] [] [] [] [] [] [] [] | bombono-dvd | [] | buzztard | [] | cflow | [] [] [] | clisp | [] | coreutils | [] [] [] [] [] | cpio | [] [] [] [] | cppi | [] [] | cpplib | [] [] [] | cryptsetup | [] [] [] | dfarc | [] [] [] | dialog | [] [] [] [] [] [] [] | dico | | diffutils | [] [] [] [] [] [] [] [] [] | dink | [] | doodle | [] [] | e2fsprogs | [] [] | enscript | [] [] [] [] | exif | [] [] [] [] [] [] | fetchmail | [] [] [] [] | findutils | [] [] [] [] [] [] | flex | [] [] [] | freedink | [] [] [] | gas | [] [] | gawk | [] [] [] [] () [] | gcal | [] | gcc | [] | gettext-examples | [] [] [] [] [] [] [] | gettext-runtime | [] [] [] [] [] [] | gettext-tools | [] [] [] [] | gip | [] [] [] [] [] [] | gjay | [] | gliv | [] () | glunarclock | [] [] [] [] | gnubiff | () [] () | gnucash | () () () () () [] | gnuedu | [] [] | gnulib | [] [] [] [] [] [] | gnunet | | gnunet-gtk | [] | gnutls | [] [] | gold | [] [] | gpe-aerial | [] [] [] | gpe-beam | [] [] [] [] | gpe-bluetooth | [] [] [] [] | gpe-calendar | [] [] | gpe-clock | [] [] [] [] [] | gpe-conf | [] [] [] [] | gpe-contacts | [] [] [] [] | gpe-edit | [] [] [] | gpe-filemanager | [] [] [] [] | gpe-go | [] [] [] [] [] | gpe-login | [] [] [] | gpe-ownerinfo | [] [] [] [] [] | gpe-package | [] [] [] | gpe-sketchbook | [] [] [] [] | gpe-su | [] [] [] [] [] [] | gpe-taskmanager | [] [] [] [] [] | gpe-timesheet | [] [] [] [] [] | gpe-today | [] [] [] [] [] [] [] | gpe-todo | [] [] [] | gphoto2 | [] [] [] [] [] [] | gprof | [] [] [] [] | gpsdrive | [] [] [] | gramadoir | [] [] [] | grep | [] [] | grub | [] [] [] [] | gsasl | [] [] [] [] [] | gss | [] [] [] [] [] | gst-plugins-bad | [] [] [] [] [] [] | gst-plugins-base | [] [] [] [] [] [] | gst-plugins-good | [] [] [] [] [] [] | gst-plugins-ugly | [] [] [] [] [] [] | gstreamer | [] [] [] [] [] | gtick | [] [] [] [] [] | gtkam | [] [] [] [] [] | gtkorphan | [] [] [] | gtkspell | [] [] [] [] [] [] [] [] [] | gutenprint | [] [] [] [] | hello | [] [] [] | help2man | [] [] | hylafax | [] | idutils | [] [] [] [] [] [] | indent | [] [] [] [] [] [] [] [] | iso_15924 | [] () [] [] | iso_3166 | [] () [] [] [] [] [] [] [] [] [] [] | iso_3166_2 | () [] [] [] | iso_4217 | [] () [] [] [] [] | iso_639 | [] () [] [] [] [] [] [] [] | iso_639_3 | () [] [] | jwhois | [] [] [] [] [] | kbd | [] [] | keytouch | [] [] [] [] [] [] | keytouch-editor | [] [] [] [] [] | keytouch-keyboa... | [] [] [] [] [] | klavaro | [] [] | latrine | [] [] [] | ld | [] [] [] [] | leafpad | [] [] [] [] [] [] [] () | libc | [] [] [] [] [] | libexif | [] | libextractor | | libgnutls | [] [] | libgpewidget | [] [] [] [] | libgpg-error | [] [] | libgphoto2 | [] [] [] | libgphoto2_port | [] [] [] | libgsasl | [] [] [] [] [] | libiconv | [] [] [] [] [] [] | libidn | [] [] [] [] | lifelines | () | liferea | [] [] [] [] | lilypond | [] [] | linkdr | [] [] [] [] [] | lordsawar | | lprng | [] | lynx | [] [] [] [] [] | m4 | [] [] [] [] [] [] | mailfromd | | mailutils | [] [] | make | [] [] [] [] [] [] [] [] [] | man-db | [] [] | man-db-manpages | [] | minicom | [] [] [] [] [] | mkisofs | [] [] [] [] | myserver | | nano | [] [] [] [] [] [] | opcodes | [] [] [] [] | parted | [] [] [] [] | pies | | popt | [] [] [] [] [] [] [] [] [] | psmisc | [] [] [] | pspp | | pwdutils | [] [] | radius | [] [] | recode | [] [] [] [] [] [] [] [] | rosegarden | () () () () () | rpm | [] [] | rush | | sarg | [] | screem | [] [] | scrollkeeper | [] [] [] [] | sed | [] [] [] [] [] [] [] [] | sharutils | [] [] [] [] [] [] [] | shishi | [] | skencil | [] | solfege | [] [] [] [] | solfege-manual | [] [] | soundtracker | [] [] | sp | [] () | sysstat | [] [] [] [] [] | tar | [] [] [] [] [] [] [] | texinfo | [] [] [] [] | tin | [] | unicode-han-tra... | | unicode-transla... | [] [] | util-linux-ng | [] [] [] [] [] [] | vice | () () () | vmm | [] | vorbis-tools | [] | wastesedge | () () | wdiff | [] | wget | [] [] [] [] [] [] [] [] | wyslij-po | [] [] [] | xchat | [] [] [] [] [] [] [] [] [] | xdg-user-dirs | [] [] [] [] [] [] [] [] [] [] [] [] [] | xkeyboard-config | [] [] [] [] [] | +----------------------------------------------------+ fi fr ga gl gu he hi hr hu hy id is it ja ka kn 105 121 53 20 4 8 3 5 53 2 120 5 84 67 0 4 ko ku ky lg lt lv mk ml mn mr ms mt nb nds ne +-----------------------------------------------+ a2ps | [] | aegis | | ant-phone | | anubis | [] [] | aspell | [] | bash | | bfd | | bibshelf | [] [] | binutils | | bison | [] | bison-runtime | [] [] [] [] [] | bluez-pin | [] [] [] [] [] | bombono-dvd | | buzztard | | cflow | | clisp | | coreutils | [] | cpio | | cppi | | cpplib | | cryptsetup | | dfarc | [] | dialog | [] [] [] [] [] | dico | | diffutils | [] [] | dink | | doodle | | e2fsprogs | | enscript | | exif | [] | fetchmail | | findutils | | flex | | freedink | [] | gas | | gawk | | gcal | | gcc | | gettext-examples | [] [] [] [] | gettext-runtime | [] | gettext-tools | [] | gip | [] [] | gjay | | gliv | | glunarclock | [] | gnubiff | | gnucash | () () () () | gnuedu | | gnulib | | gnunet | | gnunet-gtk | | gnutls | [] | gold | | gpe-aerial | [] | gpe-beam | [] | gpe-bluetooth | [] [] | gpe-calendar | [] | gpe-clock | [] [] [] [] [] | gpe-conf | [] [] | gpe-contacts | [] [] | gpe-edit | [] | gpe-filemanager | [] [] | gpe-go | [] [] [] | gpe-login | [] | gpe-ownerinfo | [] [] | gpe-package | [] [] | gpe-sketchbook | [] [] | gpe-su | [] [] [] [] [] [] | gpe-taskmanager | [] [] [] [] [] [] | gpe-timesheet | [] [] | gpe-today | [] [] [] [] | gpe-todo | [] [] | gphoto2 | | gprof | [] | gpsdrive | | gramadoir | | grep | | grub | | gsasl | | gss | | gst-plugins-bad | [] [] [] [] | gst-plugins-base | [] [] | gst-plugins-good | [] [] | gst-plugins-ugly | [] [] [] [] [] | gstreamer | | gtick | | gtkam | [] | gtkorphan | [] [] | gtkspell | [] [] [] [] [] [] [] | gutenprint | | hello | [] [] [] | help2man | | hylafax | | idutils | | indent | | iso_15924 | [] [] | iso_3166 | [] [] () [] [] [] [] [] | iso_3166_2 | | iso_4217 | [] [] | iso_639 | [] [] | iso_639_3 | [] | jwhois | [] | kbd | | keytouch | [] | keytouch-editor | [] | keytouch-keyboa... | [] | klavaro | [] | latrine | [] | ld | | leafpad | [] [] [] | libc | [] | libexif | | libextractor | | libgnutls | [] | libgpewidget | [] [] | libgpg-error | | libgphoto2 | | libgphoto2_port | | libgsasl | | libiconv | | libidn | | lifelines | | liferea | | lilypond | | linkdr | | lordsawar | | lprng | | lynx | | m4 | | mailfromd | | mailutils | | make | [] | man-db | | man-db-manpages | | minicom | [] | mkisofs | | myserver | | nano | [] [] | opcodes | | parted | | pies | | popt | [] [] [] | psmisc | | pspp | | pwdutils | | radius | | recode | | rosegarden | | rpm | | rush | | sarg | | screem | | scrollkeeper | [] [] | sed | | sharutils | | shishi | | skencil | | solfege | [] | solfege-manual | | soundtracker | | sp | | sysstat | [] | tar | [] | texinfo | [] | tin | | unicode-han-tra... | | unicode-transla... | | util-linux-ng | | vice | | vmm | | vorbis-tools | | wastesedge | | wdiff | | wget | [] | wyslij-po | | xchat | [] [] [] | xdg-user-dirs | [] [] [] [] [] [] [] [] | xkeyboard-config | [] [] [] | +-----------------------------------------------+ ko ku ky lg lt lv mk ml mn mr ms mt nb nds ne 20 5 10 1 13 48 4 2 2 4 24 10 20 3 1 nl nn or pa pl ps pt pt_BR ro ru rw sk sl sq sr +---------------------------------------------------+ a2ps | [] [] [] [] [] [] [] [] | aegis | [] [] [] | ant-phone | [] [] | anubis | [] [] [] | aspell | [] [] [] [] [] | bash | [] [] | bfd | [] | bibshelf | [] [] | binutils | [] [] | bison | [] [] [] | bison-runtime | [] [] [] [] [] [] [] | bluez-pin | [] [] [] [] [] [] [] [] | bombono-dvd | [] () | buzztard | [] [] | cflow | [] | clisp | [] [] | coreutils | [] [] [] [] [] [] | cpio | [] [] [] | cppi | [] | cpplib | [] | cryptsetup | [] | dfarc | [] | dialog | [] [] [] [] | dico | [] | diffutils | [] [] [] [] [] [] | dink | () | doodle | [] [] | e2fsprogs | [] [] | enscript | [] [] [] [] [] | exif | [] [] [] () [] | fetchmail | [] [] [] [] | findutils | [] [] [] [] [] | flex | [] [] [] [] [] | freedink | [] [] | gas | | gawk | [] [] [] [] | gcal | | gcc | [] | gettext-examples | [] [] [] [] [] [] [] [] | gettext-runtime | [] [] [] [] [] [] [] [] [] | gettext-tools | [] [] [] [] [] [] | gip | [] [] [] [] [] | gjay | | gliv | [] [] [] [] [] [] | glunarclock | [] [] [] [] [] | gnubiff | [] () | gnucash | [] () () () | gnuedu | [] | gnulib | [] [] [] [] | gnunet | | gnunet-gtk | | gnutls | [] [] | gold | | gpe-aerial | [] [] [] [] [] [] [] | gpe-beam | [] [] [] [] [] [] [] | gpe-bluetooth | [] [] | gpe-calendar | [] [] [] [] | gpe-clock | [] [] [] [] [] [] [] [] | gpe-conf | [] [] [] [] [] [] [] | gpe-contacts | [] [] [] [] [] | gpe-edit | [] [] [] | gpe-filemanager | [] [] [] | gpe-go | [] [] [] [] [] [] [] [] | gpe-login | [] [] | gpe-ownerinfo | [] [] [] [] [] [] [] [] | gpe-package | [] [] | gpe-sketchbook | [] [] [] [] [] [] [] | gpe-su | [] [] [] [] [] [] [] [] | gpe-taskmanager | [] [] [] [] [] [] [] [] | gpe-timesheet | [] [] [] [] [] [] [] [] | gpe-today | [] [] [] [] [] [] [] [] | gpe-todo | [] [] [] [] [] | gphoto2 | [] [] [] [] [] [] [] [] | gprof | [] [] [] | gpsdrive | [] [] | gramadoir | [] [] | grep | [] [] [] [] | grub | [] [] [] | gsasl | [] [] [] [] | gss | [] [] [] | gst-plugins-bad | [] [] [] [] [] [] | gst-plugins-base | [] [] [] [] [] | gst-plugins-good | [] [] [] [] [] | gst-plugins-ugly | [] [] [] [] [] [] | gstreamer | [] [] [] [] [] | gtick | [] [] [] | gtkam | [] [] [] [] [] [] | gtkorphan | [] | gtkspell | [] [] [] [] [] [] [] [] [] [] | gutenprint | [] [] | hello | [] [] [] [] | help2man | [] [] | hylafax | [] | idutils | [] [] [] [] [] | indent | [] [] [] [] [] [] [] | iso_15924 | [] [] [] [] | iso_3166 | [] [] [] [] [] () [] [] [] [] [] [] [] [] | iso_3166_2 | [] [] [] | iso_4217 | [] [] [] [] [] [] [] [] | iso_639 | [] [] [] [] [] [] [] [] [] | iso_639_3 | [] [] | jwhois | [] [] [] [] | kbd | [] [] [] | keytouch | [] [] [] | keytouch-editor | [] [] [] | keytouch-keyboa... | [] [] [] | klavaro | [] [] | latrine | [] [] | ld | | leafpad | [] [] [] [] [] [] [] [] [] | libc | [] [] [] [] | libexif | [] [] () [] | libextractor | | libgnutls | [] [] | libgpewidget | [] [] [] | libgpg-error | [] [] | libgphoto2 | [] [] | libgphoto2_port | [] [] [] [] [] | libgsasl | [] [] [] [] [] | libiconv | [] [] [] [] [] | libidn | [] [] | lifelines | [] [] | liferea | [] [] [] [] [] () () [] | lilypond | [] | linkdr | [] [] [] | lordsawar | | lprng | [] | lynx | [] [] [] | m4 | [] [] [] [] [] | mailfromd | [] | mailutils | [] | make | [] [] [] [] | man-db | [] [] [] | man-db-manpages | [] [] [] | minicom | [] [] [] [] | mkisofs | [] [] [] | myserver | | nano | [] [] [] [] | opcodes | [] [] | parted | [] [] [] [] | pies | [] | popt | [] [] [] [] | psmisc | [] [] [] | pspp | [] [] | pwdutils | [] | radius | [] [] [] | recode | [] [] [] [] [] [] [] [] | rosegarden | () () | rpm | [] [] [] | rush | [] [] | sarg | | screem | | scrollkeeper | [] [] [] [] [] [] [] [] | sed | [] [] [] [] [] [] [] [] [] | sharutils | [] [] [] [] | shishi | [] | skencil | [] [] | solfege | [] [] [] [] | solfege-manual | [] [] [] | soundtracker | [] | sp | | sysstat | [] [] [] [] | tar | [] [] [] [] | texinfo | [] [] [] [] | tin | [] | unicode-han-tra... | | unicode-transla... | | util-linux-ng | [] [] [] [] [] | vice | [] | vmm | [] | vorbis-tools | [] [] | wastesedge | [] | wdiff | [] [] | wget | [] [] [] [] [] [] [] | wyslij-po | [] [] [] | xchat | [] [] [] [] [] [] [] [] [] | xdg-user-dirs | [] [] [] [] [] [] [] [] [] [] [] [] [] [] | xkeyboard-config | [] [] [] | +---------------------------------------------------+ nl nn or pa pl ps pt pt_BR ro ru rw sk sl sq sr 135 10 4 7 105 1 29 62 47 91 3 54 46 9 37 sv sw ta te tg th tr uk vi wa zh_CN zh_HK zh_TW +---------------------------------------------------+ a2ps | [] [] [] [] [] | 27 aegis | [] | 9 ant-phone | [] [] [] [] | 9 anubis | [] [] [] [] | 15 aspell | [] [] [] | 20 bash | [] [] [] | 12 bfd | [] | 6 bibshelf | [] [] [] | 16 binutils | [] [] | 8 bison | [] [] | 12 bison-runtime | [] [] [] [] [] [] | 29 bluez-pin | [] [] [] [] [] [] [] [] | 37 bombono-dvd | [] | 4 buzztard | [] | 7 cflow | [] [] [] | 9 clisp | | 10 coreutils | [] [] [] [] | 22 cpio | [] [] [] [] [] [] | 13 cppi | [] [] | 5 cpplib | [] [] [] [] [] [] | 14 cryptsetup | [] [] | 7 dfarc | [] | 9 dialog | [] [] [] [] [] [] [] | 30 dico | [] | 2 diffutils | [] [] [] [] [] [] | 30 dink | | 4 doodle | [] [] | 7 e2fsprogs | [] [] [] | 11 enscript | [] [] [] [] | 17 exif | [] [] [] | 16 fetchmail | [] [] [] | 17 findutils | [] [] [] [] [] | 20 flex | [] [] [] [] | 15 freedink | [] | 10 gas | [] | 4 gawk | [] [] [] [] | 18 gcal | [] [] | 5 gcc | [] [] [] | 7 gettext-examples | [] [] [] [] [] [] [] | 34 gettext-runtime | [] [] [] [] [] [] [] | 29 gettext-tools | [] [] [] [] [] [] | 22 gip | [] [] [] [] | 22 gjay | [] | 3 gliv | [] [] [] | 14 glunarclock | [] [] [] [] [] | 19 gnubiff | [] [] | 4 gnucash | () [] () [] () | 10 gnuedu | [] [] | 7 gnulib | [] [] [] [] | 16 gnunet | [] | 1 gnunet-gtk | [] [] [] | 5 gnutls | [] [] [] | 10 gold | [] | 4 gpe-aerial | [] [] [] | 18 gpe-beam | [] [] [] | 19 gpe-bluetooth | [] [] [] | 13 gpe-calendar | [] [] [] [] | 12 gpe-clock | [] [] [] [] [] | 28 gpe-conf | [] [] [] [] | 20 gpe-contacts | [] [] [] | 17 gpe-edit | [] [] [] | 12 gpe-filemanager | [] [] [] [] | 16 gpe-go | [] [] [] [] [] | 25 gpe-login | [] [] [] | 11 gpe-ownerinfo | [] [] [] [] [] | 25 gpe-package | [] [] [] | 13 gpe-sketchbook | [] [] [] | 20 gpe-su | [] [] [] [] [] | 30 gpe-taskmanager | [] [] [] [] [] | 29 gpe-timesheet | [] [] [] [] [] | 25 gpe-today | [] [] [] [] [] [] | 30 gpe-todo | [] [] [] [] | 17 gphoto2 | [] [] [] [] [] | 24 gprof | [] [] [] | 15 gpsdrive | [] [] [] | 11 gramadoir | [] [] [] | 11 grep | [] [] [] | 10 grub | [] [] [] | 14 gsasl | [] [] [] [] | 14 gss | [] [] [] | 11 gst-plugins-bad | [] [] [] [] | 26 gst-plugins-base | [] [] [] [] [] | 24 gst-plugins-good | [] [] [] [] | 24 gst-plugins-ugly | [] [] [] [] [] | 29 gstreamer | [] [] [] [] | 22 gtick | [] [] [] | 13 gtkam | [] [] [] | 20 gtkorphan | [] [] [] | 14 gtkspell | [] [] [] [] [] [] [] [] [] | 45 gutenprint | [] | 10 hello | [] [] [] [] [] [] | 21 help2man | [] [] | 7 hylafax | [] | 5 idutils | [] [] [] [] | 17 indent | [] [] [] [] [] [] | 30 iso_15924 | () [] () [] [] | 16 iso_3166 | [] [] () [] [] () [] [] [] () | 53 iso_3166_2 | () [] () [] | 9 iso_4217 | [] () [] [] () [] [] | 26 iso_639 | [] [] [] () [] () [] [] [] [] | 38 iso_639_3 | [] () | 8 jwhois | [] [] [] [] [] | 16 kbd | [] [] [] [] [] | 15 keytouch | [] [] [] | 16 keytouch-editor | [] [] [] | 14 keytouch-keyboa... | [] [] [] | 14 klavaro | [] | 11 latrine | [] [] [] | 10 ld | [] [] [] [] | 11 leafpad | [] [] [] [] [] [] | 33 libc | [] [] [] [] [] | 21 libexif | [] () | 7 libextractor | [] | 1 libgnutls | [] [] [] | 9 libgpewidget | [] [] [] | 14 libgpg-error | [] [] [] | 9 libgphoto2 | [] [] | 8 libgphoto2_port | [] [] [] [] | 14 libgsasl | [] [] [] | 13 libiconv | [] [] [] [] | 21 libidn | () [] [] | 11 lifelines | [] | 4 liferea | [] [] [] | 21 lilypond | [] | 7 linkdr | [] [] [] [] [] | 17 lordsawar | | 1 lprng | [] | 3 lynx | [] [] [] [] | 17 m4 | [] [] [] [] | 19 mailfromd | [] [] | 3 mailutils | [] | 5 make | [] [] [] [] | 21 man-db | [] [] [] | 8 man-db-manpages | | 4 minicom | [] [] | 16 mkisofs | [] [] | 9 myserver | | 0 nano | [] [] [] [] | 21 opcodes | [] [] [] | 11 parted | [] [] [] [] [] | 15 pies | [] [] | 3 popt | [] [] [] [] [] [] | 27 psmisc | [] [] | 11 pspp | | 4 pwdutils | [] [] | 6 radius | [] [] | 9 recode | [] [] [] [] | 28 rosegarden | () | 0 rpm | [] [] [] | 11 rush | [] [] | 4 sarg | | 1 screem | [] | 3 scrollkeeper | [] [] [] [] [] | 27 sed | [] [] [] [] [] | 30 sharutils | [] [] [] [] [] | 22 shishi | [] | 3 skencil | [] [] | 7 solfege | [] [] [] [] | 16 solfege-manual | [] | 8 soundtracker | [] [] [] | 9 sp | [] | 3 sysstat | [] [] | 15 tar | [] [] [] [] [] [] | 23 texinfo | [] [] [] [] [] | 17 tin | | 4 unicode-han-tra... | | 0 unicode-transla... | | 2 util-linux-ng | [] [] [] [] | 20 vice | () () | 1 vmm | [] | 4 vorbis-tools | [] | 6 wastesedge | | 2 wdiff | [] [] | 7 wget | [] [] [] [] [] | 26 wyslij-po | [] [] | 8 xchat | [] [] [] [] [] [] | 36 xdg-user-dirs | [] [] [] [] [] [] [] [] [] [] | 63 xkeyboard-config | [] [] [] | 22 +---------------------------------------------------+ 85 teams sv sw ta te tg th tr uk vi wa zh_CN zh_HK zh_TW 178 domains 119 1 3 3 0 10 65 51 155 17 98 7 41 2618 Some counters in the preceding matrix are higher than the number of visible blocks let us expect. This is because a few extra PO files are used for implementing regional variants of languages, or language dialects. For a PO file in the matrix above to be effective, the package to which it applies should also have been internationalized and distributed as such by its maintainer. There might be an observable lag between the mere existence a PO file and its wide availability in a distribution. If June 2010 seems to be old, you may fetch a more recent copy of this `ABOUT-NLS' file on most GNU archive sites. The most up-to-date matrix with full percentage details can be found at `http://translationproject.org/extra/matrix.html'. 1.5 Using `gettext' in new packages =================================== If you are writing a freely available program and want to internationalize it you are welcome to use GNU `gettext' in your package. Of course you have to respect the GNU Library General Public License which covers the use of the GNU `gettext' library. This means in particular that even non-free programs can use `libintl' as a shared library, whereas only free software can use `libintl' as a static library or use modified versions of `libintl'. Once the sources are changed appropriately and the setup can handle the use of `gettext' the only thing missing are the translations. The Free Translation Project is also available for packages which are not developed inside the GNU project. Therefore the information given above applies also for every other Free Software Project. Contact `coordinator@translationproject.org' to make the `.pot' files available to the translation teams. connman-ui-0_20150622+dfsg.orig/.gitignore0000644000175000017500000000054212541725135016546 0ustar nicknick*.o *.a *.lo *.la *.swp *.patch *.gmo .deps .libs .dirstamp Makefile Makefile.in aclocal.m4 config config.h config.h.in config.log config.status configure depcomp compile install-sh libtool ltmain.sh missing stamp-h1 autom4te.cache connman-ui.pc config.guess config.sub src/connman-ui-gtk include/version.h po/POTFILES po/remove-potcdate.sed po/stamp-it connman-ui-0_20150622+dfsg.orig/INSTALL0000644000175000017500000002240612541725135015612 0ustar nicknickInstallation Instructions ************************* Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005 Free Software Foundation, Inc. This file is free documentation; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. Basic Installation ================== These are generic installation instructions. The `configure' shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a `Makefile' in each directory of the package. It may also create one or more `.h' files containing system-dependent definitions. Finally, it creates a shell script `config.status' that you can run in the future to recreate the current configuration, and a file `config.log' containing compiler output (useful mainly for debugging `configure'). It can also use an optional file (typically called `config.cache' and enabled with `--cache-file=config.cache' or simply `-C') that saves the results of its tests to speed up reconfiguring. (Caching is disabled by default to prevent problems with accidental use of stale cache files.) If you need to do unusual things to compile the package, please try to figure out how `configure' could check whether to do them, and mail diffs or instructions to the address given in the `README' so they can be considered for the next release. If you are using the cache, and at some point `config.cache' contains results you don't want to keep, you may remove or edit it. The file `configure.ac' (or `configure.in') is used to create `configure' by a program called `autoconf'. You only need `configure.ac' if you want to change it or regenerate `configure' using a newer version of `autoconf'. The simplest way to compile this package is: 1. `cd' to the directory containing the package's source code and type `./configure' to configure the package for your system. If you're using `csh' on an old version of System V, you might need to type `sh ./configure' instead to prevent `csh' from trying to execute `configure' itself. Running `configure' takes awhile. While running, it prints some messages telling which features it is checking for. 2. Type `make' to compile the package. 3. Optionally, type `make check' to run any self-tests that come with the package. 4. Type `make install' to install the programs and any data files and documentation. 5. You can remove the program binaries and object files from the source code directory by typing `make clean'. To also remove the files that `configure' created (so you can compile the package for a different kind of computer), type `make distclean'. There is also a `make maintainer-clean' target, but that is intended mainly for the package's developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution. Compilers and Options ===================== Some systems require unusual options for compilation or linking that the `configure' script does not know about. Run `./configure --help' for details on some of the pertinent environment variables. You can give `configure' initial values for configuration parameters by setting variables in the command line or in the environment. Here is an example: ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix *Note Defining Variables::, for more details. Compiling For Multiple Architectures ==================================== You can compile the package for more than one kind of computer at the same time, by placing the object files for each architecture in their own directory. To do this, you must use a version of `make' that supports the `VPATH' variable, such as GNU `make'. `cd' to the directory where you want the object files and executables to go and run the `configure' script. `configure' automatically checks for the source code in the directory that `configure' is in and in `..'. If you have to use a `make' that does not support the `VPATH' variable, you have to compile the package for one architecture at a time in the source code directory. After you have installed the package for one architecture, use `make distclean' before reconfiguring for another architecture. Installation Names ================== By default, `make install' will install the package's files in `/usr/local/bin', `/usr/local/man', etc. You can specify an installation prefix other than `/usr/local' by giving `configure' the option `--prefix=PREFIX'. You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you give `configure' the option `--exec-prefix=PREFIX', the package will use PREFIX as the prefix for installing programs and libraries. Documentation and other data files will still use the regular prefix. In addition, if you use an unusual directory layout you can give options like `--bindir=DIR' to specify different values for particular kinds of files. Run `configure --help' for a list of the directories you can set and what kinds of files go in them. If the package supports it, you can cause programs to be installed with an extra prefix or suffix on their names by giving `configure' the option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'. Optional Features ================= Some packages pay attention to `--enable-FEATURE' options to `configure', where FEATURE indicates an optional part of the package. They may also pay attention to `--with-PACKAGE' options, where PACKAGE is something like `gnu-as' or `x' (for the X Window System). The `README' should mention any `--enable-' and `--with-' options that the package recognizes. For packages that use the X Window System, `configure' can usually find the X include and library files automatically, but if it doesn't, you can use the `configure' options `--x-includes=DIR' and `--x-libraries=DIR' to specify their locations. Specifying the System Type ========================== There may be some features `configure' cannot figure out automatically, but needs to determine by the type of machine the package will run on. Usually, assuming the package is built to be run on the _same_ architectures, `configure' can figure that out, but if it prints a message saying it cannot guess the machine type, give it the `--build=TYPE' option. TYPE can either be a short name for the system type, such as `sun4', or a canonical name which has the form: CPU-COMPANY-SYSTEM where SYSTEM can have one of these forms: OS KERNEL-OS See the file `config.sub' for the possible values of each field. If `config.sub' isn't included in this package, then this package doesn't need to know the machine type. If you are _building_ compiler tools for cross-compiling, you should use the `--target=TYPE' option to select the type of system they will produce code for. If you want to _use_ a cross compiler, that generates code for a platform different from the build platform, you should specify the "host" platform (i.e., that on which the generated programs will eventually be run) with `--host=TYPE'. Sharing Defaults ================ If you want to set default values for `configure' scripts to share, you can create a site shell script called `config.site' that gives default values for variables like `CC', `cache_file', and `prefix'. `configure' looks for `PREFIX/share/config.site' if it exists, then `PREFIX/etc/config.site' if it exists. Or, you can set the `CONFIG_SITE' environment variable to the location of the site script. A warning: not all `configure' scripts look for a site script. Defining Variables ================== Variables not defined in a site shell script can be set in the environment passed to `configure'. However, some packages may run configure again during the build, and the customized values of these variables may be lost. In order to avoid this problem, you should set them in the `configure' command line, using `VAR=value'. For example: ./configure CC=/usr/local2/bin/gcc causes the specified `gcc' to be used as the C compiler (unless it is overridden in the site shell script). Here is a another example: /bin/bash ./configure CONFIG_SHELL=/bin/bash Here the `CONFIG_SHELL=/bin/bash' operand causes subsequent configuration-related scripts to be executed by `/bin/bash'. `configure' Invocation ====================== `configure' recognizes the following options to control how it operates. `--help' `-h' Print a summary of the options to `configure', and exit. `--version' `-V' Print the version of Autoconf used to generate the `configure' script, and exit. `--cache-file=FILE' Enable the cache: use and save the results of the tests in FILE, traditionally `config.cache'. FILE defaults to `/dev/null' to disable caching. `--config-cache' `-C' Alias for `--cache-file=config.cache'. `--quiet' `--silent' `-q' Do not print messages saying which checks are being made. To suppress all normal output, redirect it to `/dev/null' (any error messages will still be shown). `--srcdir=DIR' Look for the package's source code in directory DIR. Usually `configure' can determine that directory automatically. `configure' also accepts some other, not widely useful, options. Run `configure --help' for more details. connman-ui-0_20150622+dfsg.orig/clean.sh0000755000175000017500000000054312541725135016200 0ustar nicknick#!/bin/sh rm -f aclocal.m4 compile configure rm -rf autom4te.cache/ rm -rf config config.sub config.guess find ./ -type f -name "config.h*" -delete; find ./ -type f -name "Makefile.in" -delete; find ./ -type f -name "*.xml" -delete; find ./ -type f -name "*.gcno" -delete; find ./ -type f -name "*.gcda" -delete; find ./ -type f -name "*.gcov" -delete; connman-ui-0_20150622+dfsg.orig/COPYING0000644000175000017500000004312612541725135015616 0ustar nicknick GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. connman-ui-0_20150622+dfsg.orig/README0000644000175000017500000000243712541725135015443 0ustar nicknickConnMan-UI ========== A full-featured GTK based trayicon UI for ConnMan. It targets all WM/DM users but Gnome3 ones*. It works on any Linux WM/DM which provides a freedesktop compliant system tray. (kde, awesome, ...) It exposes almost all features provided by ConnMan API (small features are missing, see TODO for more information). You can enable/disable a technology (wired, wifi, cellular, bt, ...), connect/disconnect a service, configure a service (IPv4, IPv6, DNS, Timeservers, etc...), share your current connection (tethering) and so on. Everything is accessible through the mouse via the trayicon, all with left and right click. Requirements ------------ - libdbus ( >= 1.4 ) - glib ( >= 2.28 ) - gtk+ ( >=3.0 ) Compilation and installation ---------------------------- ./bootstrap && ./configure --prefix=usr && make && sudo make install Notes ----- This is an alpha stage software. Though it has proven to be stable, the look and feel require still lot of work, thus contributions are welcome! If you want to contribute please take a look at the TODO file and/or come to #connman@irc.freenode.net Send patches to: connman<_at_>connman.net CC to: tomasz.bursztyka<_at_>linux.intel.com *: for Gnome3 users please look for connman-extension in https://extensions.gnome.org/ connman-ui-0_20150622+dfsg.orig/AUTHORS0000644000175000017500000000005612541725135015626 0ustar nicknickTomasz Bursztyka connman-ui-0_20150622+dfsg.orig/config.rpath0000755000175000017500000004401212541725135017066 0ustar nicknick#! /bin/sh # Output a system dependent set of variables, describing how to set the # run time search path of shared libraries in an executable. # # Copyright 1996-2010 Free Software Foundation, Inc. # Taken from GNU libtool, 2001 # Originally by Gordon Matzigkeit , 1996 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # # The first argument passed to this file is the canonical host specification, # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # The environment variables CC, GCC, LDFLAGS, LD, with_gnu_ld # should be set by the caller. # # The set of defined variables is at the end of this script. # Known limitations: # - On IRIX 6.5 with CC="cc", the run time search patch must not be longer # than 256 bytes, otherwise the compiler driver will dump core. The only # known workaround is to choose shorter directory names for the build # directory and/or the installation directory. # All known linkers require a `.a' archive for static linking (except MSVC, # which needs '.lib'). libext=a shrext=.so host="$1" host_cpu=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` host_vendor=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` host_os=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` # Code taken from libtool.m4's _LT_CC_BASENAME. for cc_temp in $CC""; do case $cc_temp in compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; \-*) ;; *) break;; esac done cc_basename=`echo "$cc_temp" | sed -e 's%^.*/%%'` # Code taken from libtool.m4's _LT_COMPILER_PIC. wl= if test "$GCC" = yes; then wl='-Wl,' else case "$host_os" in aix*) wl='-Wl,' ;; darwin*) case $cc_basename in xlc*) wl='-Wl,' ;; esac ;; mingw* | cygwin* | pw32* | os2* | cegcc*) ;; hpux9* | hpux10* | hpux11*) wl='-Wl,' ;; irix5* | irix6* | nonstopux*) wl='-Wl,' ;; newsos6) ;; linux* | k*bsd*-gnu) case $cc_basename in ecc*) wl='-Wl,' ;; icc* | ifort*) wl='-Wl,' ;; lf95*) wl='-Wl,' ;; pgcc | pgf77 | pgf90) wl='-Wl,' ;; ccc*) wl='-Wl,' ;; como) wl='-lopt=' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) wl='-Wl,' ;; esac ;; esac ;; osf3* | osf4* | osf5*) wl='-Wl,' ;; rdos*) ;; solaris*) wl='-Wl,' ;; sunos4*) wl='-Qoption ld ' ;; sysv4 | sysv4.2uw2* | sysv4.3*) wl='-Wl,' ;; sysv4*MP*) ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) wl='-Wl,' ;; unicos*) wl='-Wl,' ;; uts4*) ;; esac fi # Code taken from libtool.m4's _LT_LINKER_SHLIBS. hardcode_libdir_flag_spec= hardcode_libdir_separator= hardcode_direct=no hardcode_minus_L=no case "$host_os" in cygwin* | mingw* | pw32* | cegcc*) # FIXME: the MSVC++ port hasn't been tested in a loooong time # When not using gcc, we currently assume that we are using # Microsoft Visual C++. if test "$GCC" != yes; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd*) with_gnu_ld=no ;; esac ld_shlibs=yes if test "$with_gnu_ld" = yes; then # Set some defaults for GNU ld with shared library support. These # are reset later if shared libraries are not supported. Putting them # here allows them to be overridden if necessary. # Unlike libtool, we use -rpath here, not --rpath, since the documented # option of GNU ld is called -rpath, not --rpath. hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' case "$host_os" in aix[3-9]*) # On AIX/PPC, the GNU linker is very broken if test "$host_cpu" != ia64; then ld_shlibs=no fi ;; amigaos*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes # Samuel A. Falvo II reports # that the semantics of dynamic libraries on AmigaOS, at least up # to version 4, is to share data among multiple programs linked # with the same dynamic library. Since this doesn't match the # behavior of shared libraries on other platforms, we cannot use # them. ld_shlibs=no ;; beos*) if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then : else ld_shlibs=no fi ;; cygwin* | mingw* | pw32* | cegcc*) # hardcode_libdir_flag_spec is actually meaningless, as there is # no search path for DLLs. hardcode_libdir_flag_spec='-L$libdir' if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then : else ld_shlibs=no fi ;; interix[3-9]*) hardcode_direct=no hardcode_libdir_flag_spec='${wl}-rpath,$libdir' ;; gnu* | linux* | k*bsd*-gnu) if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then : else ld_shlibs=no fi ;; netbsd*) ;; solaris*) if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then ld_shlibs=no elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then : else ld_shlibs=no fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) case `$LD -v 2>&1` in *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*) ld_shlibs=no ;; *) if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`' else ld_shlibs=no fi ;; esac ;; sunos4*) hardcode_direct=yes ;; *) if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then : else ld_shlibs=no fi ;; esac if test "$ld_shlibs" = no; then hardcode_libdir_flag_spec= fi else case "$host_os" in aix3*) # Note: this linker hardcodes the directories in LIBPATH if there # are no directories specified by -L. hardcode_minus_L=yes if test "$GCC" = yes; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. hardcode_direct=unsupported fi ;; aix[4-9]*) if test "$host_cpu" = ia64; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no else aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we # need to do runtime linking. case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) for ld_flag in $LDFLAGS; do if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then aix_use_runtimelinking=yes break fi done ;; esac fi hardcode_direct=yes hardcode_libdir_separator=':' if test "$GCC" = yes; then case $host_os in aix4.[012]|aix4.[012].*) collect2name=`${CC} -print-prog-name=collect2` if test -f "$collect2name" && \ strings "$collect2name" | grep resolve_lib_name >/dev/null then # We have reworked collect2 : else # We have old collect2 hardcode_direct=unsupported hardcode_minus_L=yes hardcode_libdir_flag_spec='-L$libdir' hardcode_libdir_separator= fi ;; esac fi # Begin _LT_AC_SYS_LIBPATH_AIX. echo 'int main () { return 0; }' > conftest.c ${CC} ${LDFLAGS} conftest.c -o conftest aix_libpath=`dump -H conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } }'` if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } }'` fi if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib" fi rm -f conftest.c conftest # End _LT_AC_SYS_LIBPATH_AIX. if test "$aix_use_runtimelinking" = yes; then hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" else if test "$host_cpu" = ia64; then hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' else hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" fi fi ;; amigaos*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes # see comment about different semantics on the GNU ld section ld_shlibs=no ;; bsdi[45]*) ;; cygwin* | mingw* | pw32* | cegcc*) # When not using gcc, we currently assume that we are using # Microsoft Visual C++. # hardcode_libdir_flag_spec is actually meaningless, as there is # no search path for DLLs. hardcode_libdir_flag_spec=' ' libext=lib ;; darwin* | rhapsody*) hardcode_direct=no if test "$GCC" = yes ; then : else case $cc_basename in xlc*) ;; *) ld_shlibs=no ;; esac fi ;; dgux*) hardcode_libdir_flag_spec='-L$libdir' ;; freebsd1*) ld_shlibs=no ;; freebsd2.2*) hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes ;; freebsd2*) hardcode_direct=yes hardcode_minus_L=yes ;; freebsd* | dragonfly*) hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes ;; hpux9*) hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' hardcode_libdir_separator=: hardcode_direct=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. hardcode_minus_L=yes ;; hpux10*) if test "$with_gnu_ld" = no; then hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' hardcode_libdir_separator=: hardcode_direct=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. hardcode_minus_L=yes fi ;; hpux11*) if test "$with_gnu_ld" = no; then hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' hardcode_libdir_separator=: case $host_cpu in hppa*64*|ia64*) hardcode_direct=no ;; *) hardcode_direct=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. hardcode_minus_L=yes ;; esac fi ;; irix5* | irix6* | nonstopux*) hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator=: ;; netbsd*) hardcode_libdir_flag_spec='-R$libdir' hardcode_direct=yes ;; newsos6) hardcode_direct=yes hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator=: ;; openbsd*) if test -f /usr/libexec/ld.so; then hardcode_direct=yes if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then hardcode_libdir_flag_spec='${wl}-rpath,$libdir' else case "$host_os" in openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) hardcode_libdir_flag_spec='-R$libdir' ;; *) hardcode_libdir_flag_spec='${wl}-rpath,$libdir' ;; esac fi else ld_shlibs=no fi ;; os2*) hardcode_libdir_flag_spec='-L$libdir' hardcode_minus_L=yes ;; osf3*) hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' hardcode_libdir_separator=: ;; osf4* | osf5*) if test "$GCC" = yes; then hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' else # Both cc and cxx compiler support -rpath directly hardcode_libdir_flag_spec='-rpath $libdir' fi hardcode_libdir_separator=: ;; solaris*) hardcode_libdir_flag_spec='-R$libdir' ;; sunos4*) hardcode_libdir_flag_spec='-L$libdir' hardcode_direct=yes hardcode_minus_L=yes ;; sysv4) case $host_vendor in sni) hardcode_direct=yes # is this really true??? ;; siemens) hardcode_direct=no ;; motorola) hardcode_direct=no #Motorola manual says yes, but my tests say they lie ;; esac ;; sysv4.3*) ;; sysv4*MP*) if test -d /usr/nec; then ld_shlibs=yes fi ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) ;; sysv5* | sco3.2v5* | sco5v6*) hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`' hardcode_libdir_separator=':' ;; uts4*) hardcode_libdir_flag_spec='-L$libdir' ;; *) ld_shlibs=no ;; esac fi # Check dynamic linker characteristics # Code taken from libtool.m4's _LT_SYS_DYNAMIC_LINKER. # Unlike libtool.m4, here we don't care about _all_ names of the library, but # only about the one the linker finds when passed -lNAME. This is the last # element of library_names_spec in libtool.m4, or possibly two of them if the # linker has special search rules. library_names_spec= # the last element of library_names_spec in libtool.m4 libname_spec='lib$name' case "$host_os" in aix3*) library_names_spec='$libname.a' ;; aix[4-9]*) library_names_spec='$libname$shrext' ;; amigaos*) library_names_spec='$libname.a' ;; beos*) library_names_spec='$libname$shrext' ;; bsdi[45]*) library_names_spec='$libname$shrext' ;; cygwin* | mingw* | pw32* | cegcc*) shrext=.dll library_names_spec='$libname.dll.a $libname.lib' ;; darwin* | rhapsody*) shrext=.dylib library_names_spec='$libname$shrext' ;; dgux*) library_names_spec='$libname$shrext' ;; freebsd1*) ;; freebsd* | dragonfly*) case "$host_os" in freebsd[123]*) library_names_spec='$libname$shrext$versuffix' ;; *) library_names_spec='$libname$shrext' ;; esac ;; gnu*) library_names_spec='$libname$shrext' ;; hpux9* | hpux10* | hpux11*) case $host_cpu in ia64*) shrext=.so ;; hppa*64*) shrext=.sl ;; *) shrext=.sl ;; esac library_names_spec='$libname$shrext' ;; interix[3-9]*) library_names_spec='$libname$shrext' ;; irix5* | irix6* | nonstopux*) library_names_spec='$libname$shrext' case "$host_os" in irix5* | nonstopux*) libsuff= shlibsuff= ;; *) case $LD in *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= ;; *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 ;; *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 ;; *) libsuff= shlibsuff= ;; esac ;; esac ;; linux*oldld* | linux*aout* | linux*coff*) ;; linux* | k*bsd*-gnu) library_names_spec='$libname$shrext' ;; knetbsd*-gnu) library_names_spec='$libname$shrext' ;; netbsd*) library_names_spec='$libname$shrext' ;; newsos6) library_names_spec='$libname$shrext' ;; nto-qnx*) library_names_spec='$libname$shrext' ;; openbsd*) library_names_spec='$libname$shrext$versuffix' ;; os2*) libname_spec='$name' shrext=.dll library_names_spec='$libname.a' ;; osf3* | osf4* | osf5*) library_names_spec='$libname$shrext' ;; rdos*) ;; solaris*) library_names_spec='$libname$shrext' ;; sunos4*) library_names_spec='$libname$shrext$versuffix' ;; sysv4 | sysv4.3*) library_names_spec='$libname$shrext' ;; sysv4*MP*) library_names_spec='$libname$shrext' ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) library_names_spec='$libname$shrext' ;; uts4*) library_names_spec='$libname$shrext' ;; esac sed_quote_subst='s/\(["`$\\]\)/\\\1/g' escaped_wl=`echo "X$wl" | sed -e 's/^X//' -e "$sed_quote_subst"` shlibext=`echo "$shrext" | sed -e 's,^\.,,'` escaped_libname_spec=`echo "X$libname_spec" | sed -e 's/^X//' -e "$sed_quote_subst"` escaped_library_names_spec=`echo "X$library_names_spec" | sed -e 's/^X//' -e "$sed_quote_subst"` escaped_hardcode_libdir_flag_spec=`echo "X$hardcode_libdir_flag_spec" | sed -e 's/^X//' -e "$sed_quote_subst"` LC_ALL=C sed -e 's/^\([a-zA-Z0-9_]*\)=/acl_cv_\1=/' < #include #define CUI_SETTINGS_UI_PATH CUI_UI_PATH "/settings.ui" static GtkBuilder *builder = NULL; static GtkDialog *service_settings_dbox = NULL; static char *path = NULL; static gboolean ipv4_changed = FALSE; static const char *ipv4_method = NULL; static gboolean ipv6_changed = FALSE; static const char *ipv6_method = NULL; static const char *ipv6_privacy = NULL; static gboolean proxy_changed = FALSE; static const char *proxy_method = NULL; static gboolean nameservers_changed = FALSE; static gboolean domains_changed = FALSE; static gboolean timeservers_changed = FALSE; static inline void toggle_button(const char *name) { GtkToggleButton *button; button = (GtkToggleButton *) gtk_builder_get_object(builder, name); if (button == NULL) return; gtk_toggle_button_set_active(button, TRUE); } static void favorite_button_toggled(GtkToggleButton *togglebutton, gpointer user_data) { if (gtk_toggle_button_get_active(togglebutton) == FALSE) connman_service_remove(path); } static void autoconnect_button_toggled(GtkToggleButton *togglebutton, gpointer user_data) { connman_service_set_autoconnectable(path, gtk_toggle_button_get_active(togglebutton)); } static void update_header(void) { GdkPixbuf *image = NULL; const char *type, *info; GtkWidget *widget; gboolean favorite; type = connman_service_get_type(path); if (g_strcmp0(type, "wifi") == 0) { uint8_t strength; strength = connman_service_get_strength(path); cui_theme_get_signal_icone_and_info(strength, &image, &info); } else cui_theme_get_type_icone_and_info(type, &image, &info); set_image(builder, "service_type", image, info); set_label(builder, "service_name", connman_service_get_name(path), "- Hidden -"); if (connman_service_is_connected(path) == TRUE) cui_theme_get_state_icone_and_info( connman_service_get_state(path), &image, &info); else image = NULL; set_image(builder, "service_state", image, info); set_label(builder, "service_error", connman_service_get_error(path), ""); favorite = connman_service_is_favorite(path); set_button_toggle(builder, "service_autoconnect", connman_service_is_autoconnect(path)); widget = set_widget_sensitive(builder, "service_autoconnect", favorite); if (favorite == TRUE) { g_signal_connect(widget, "toggled", G_CALLBACK(autoconnect_button_toggled), NULL); } set_button_toggle(builder, "service_favorite", favorite); widget = set_widget_sensitive(builder, "service_favorite", favorite); if (favorite == TRUE) { g_signal_connect(widget, "toggled", G_CALLBACK(favorite_button_toggled), NULL); } } static void enable_ipv4_config(gboolean enable) { set_widget_sensitive(builder, "ipv4_conf_address", enable); set_widget_sensitive(builder, "ipv4_conf_netmask", enable); set_widget_sensitive(builder, "ipv4_conf_gateway", enable); } static void set_ipv4_method(const char *method) { if (g_strcmp0(method, "dhcp") == 0) { toggle_button("ipv4_dhcp"); enable_ipv4_config(FALSE); } else if (g_strcmp0(method, "manual") == 0) { toggle_button("ipv4_manual"); enable_ipv4_config(TRUE); } else { toggle_button("ipv4_off"); enable_ipv4_config(FALSE); } } static void update_ipv4(void) { const struct connman_ipv4 *ipv4, *ipv4_conf; gboolean method_set = FALSE; ipv4 = connman_service_get_ipv4(path); ipv4_conf = connman_service_get_ipv4_config(path); if (ipv4 == NULL) { set_entry(builder, "ipv4_address", "", ""); set_entry(builder, "ipv4_netmask", "", ""); set_entry(builder, "ipv4_gateway", "", ""); goto config; } set_ipv4_method(ipv4->method); method_set = TRUE; set_entry(builder, "ipv4_address", ipv4->address, ""); set_entry(builder, "ipv4_netmask", ipv4->netmask, ""); set_entry(builder, "ipv4_gateway", ipv4->gateway, ""); config: if (ipv4_conf == NULL) { set_entry(builder, "ipv4_conf_address", "", ""); set_entry(builder, "ipv4_conf_netmask", "", ""); set_entry(builder, "ipv4_conf_gateway", "", ""); if (ipv4 == NULL) set_widget_sensitive(builder, "ipv4_settings", FALSE); return; } if (method_set == FALSE) set_ipv4_method(ipv4_conf->method); set_entry(builder, "ipv4_conf_address", ipv4_conf->address, ""); set_entry(builder, "ipv4_conf_netmask", ipv4_conf->netmask, ""); set_entry(builder, "ipv4_conf_gateway", ipv4_conf->gateway, ""); set_widget_sensitive(builder, "ipv4_settings", TRUE); } static void enable_ipv6_config(gboolean enable) { set_widget_sensitive(builder, "ipv6_conf_address", enable); set_widget_sensitive(builder, "ipv6_conf_prefix_length", enable); set_widget_sensitive(builder, "ipv6_conf_gateway", enable); } static void set_ipv6_method(const char *method) { gboolean privacy_enabled = FALSE; if (g_strcmp0(method, "auto") == 0) { toggle_button("ipv6_auto"); enable_ipv6_config(FALSE); privacy_enabled = TRUE; } else if (g_strcmp0(method, "manual") == 0) { toggle_button("ipv6_manual"); enable_ipv6_config(TRUE); } else { toggle_button("ipv6_off"); enable_ipv6_config(FALSE); } set_widget_sensitive(builder, "ipv6_priv_box", privacy_enabled); } static void set_ipv6_privacy(const char *privacy) { if (g_strcmp0(privacy, "enabled") == 0) toggle_button("ipv6_priv_enabled"); else if (g_strcmp0(privacy, "prefered") == 0) toggle_button("ipv6_priv_prefered"); else toggle_button("ipv6_priv_disabled"); } static void update_ipv6(void) { const struct connman_ipv6 *ipv6, *ipv6_conf; gboolean method_set = FALSE; gboolean privacy_set = FALSE; char value[6]; ipv6 = connman_service_get_ipv6(path); ipv6_conf = connman_service_get_ipv6_config(path); if (ipv6 == NULL) { set_entry(builder, "ipv6_address", "", ""); set_entry(builder, "ipv6_prefix_length", "", ""); set_entry(builder, "ipv6_gateway", "", ""); goto config; } memset(value, 0, 6); snprintf(value, 6, "%u", ipv6->prefix); set_ipv6_method(ipv6->method); method_set = TRUE; set_label(builder, "ipv6_address", ipv6->address, ""); set_label(builder, "ipv6_prefix_length", value, ""); set_label(builder, "ipv6_gateway", ipv6->gateway, ""); set_ipv6_privacy(ipv6->privacy); privacy_set = TRUE; config: if (ipv6_conf == NULL) { set_entry(builder, "ipv6_conf_address", "", ""); set_entry(builder, "ipv6_conf_prefix_length", "", ""); set_entry(builder, "ipv6_conf_gateway", "", ""); if (ipv6 == NULL) set_widget_sensitive(builder, "ipv6_settings", FALSE); return; } memset(value, 0, 6); snprintf(value, 6, "%u", ipv6_conf->prefix); if (method_set == FALSE) set_ipv6_method(ipv6_conf->method); set_entry(builder, "ipv6_conf_address", ipv6_conf->address, ""); set_entry(builder, "ipv6_conf_prefix_length", value, ""); set_entry(builder, "ipv6_conf_gateway", ipv6_conf->gateway, ""); if (privacy_set == FALSE) set_ipv6_privacy(ipv6_conf->privacy); } static void update_dns(void) { const char *dns, *dns_config, *domains, *domains_config; dns = connman_service_get_nameservers(path); dns_config = connman_service_get_nameservers_config(path); domains = connman_service_get_domains(path); domains_config = connman_service_get_domains_config(path); set_entry(builder, "nameservers", dns, ""); set_entry(builder, "nameservers_conf", dns_config, ""); set_entry(builder, "domains", domains, ""); set_entry(builder, "domains_conf", domains_config, ""); } static void update_timeservers(void) { set_entry(builder, "timerservers", connman_service_get_timeservers(path), ""); set_entry(builder, "timerservers_conf", connman_service_get_timeservers_config(path), ""); } static void enable_proxy_config(gboolean enable) { set_widget_sensitive(builder, "proxy_conf_url", enable); set_widget_sensitive(builder, "proxy_conf_servers", enable); set_widget_sensitive(builder, "proxy_conf_excludes", enable); } static void set_proxy_method(const char *method) { if (g_strcmp0(method, "auto") == 0) { toggle_button("proxy_auto"); enable_proxy_config(FALSE); } else if (g_strcmp0(method, "direct") == 0) { toggle_button("proxy_direct"); enable_proxy_config(FALSE); } else { toggle_button("proxy_manual"); enable_proxy_config(TRUE); } } static void update_proxy(void) { const struct connman_proxy *proxy, *proxy_conf; gboolean method_set = FALSE; proxy = connman_service_get_proxy(path); proxy_conf = connman_service_get_proxy_config(path); if (proxy == NULL) { set_label(builder, "proxy_method", "", ""); set_entry(builder, "proxy_url", "", ""); set_entry(builder, "proxy_servers", "", ""); set_entry(builder, "proxy_excludes", "", ""); goto config; } set_proxy_method(proxy->method); method_set = TRUE; set_entry(builder, "proxy_url", proxy->url, ""); set_entry(builder, "proxy_servers", proxy->servers, ""); set_entry(builder, "proxy_excludes", proxy->excludes, ""); config: if (proxy_conf == NULL) { set_entry(builder, "proxy_conf_url", "", ""); set_entry(builder, "proxy_conf_servers", "", ""); set_entry(builder, "proxy_conf_excludes", "", ""); if (proxy == NULL) set_widget_sensitive(builder, "proxy_settings", FALSE); return; } if (method_set == FALSE) set_proxy_method(proxy_conf->method); set_entry(builder, "proxy_conf_url", proxy_conf->url, ""); set_entry(builder, "proxy_conf_servers", proxy_conf->servers, ""); set_entry(builder, "proxy_conf_excludes", proxy_conf->excludes, ""); set_widget_sensitive(builder, "proxy_settings", TRUE); } static void update_provider(void) { const struct connman_provider *provider; provider = connman_service_get_provider(path); if (provider == NULL) { set_label(builder, "provider_host", "", ""); set_label(builder, "provider_domain", "", ""); set_label(builder, "provider_name", "", ""); set_label(builder, "provider_type", "", ""); set_widget_sensitive(builder, "provider_settings", FALSE); return; } set_label(builder, "provider_host", provider->host, ""); set_label(builder, "provider_domain", provider->domain, ""); set_label(builder, "provider_name", provider->name, ""); set_label(builder, "provider_type", provider->type, ""); set_widget_sensitive(builder, "provider_settings", TRUE); } static void update_ethernet(void) { const struct connman_ethernet *ethernet; char value[6]; ethernet = connman_service_get_ethernet(path); if (ethernet == NULL) { set_label(builder, "ethernet_method", "", ""); set_label(builder, "ethernet_interface", "", ""); set_label(builder, "ethernet_address", "", ""); set_label(builder, "ethernet_mtu", "0", ""); set_label(builder, "ethernet_speed", "0", ""); set_label(builder, "ethernet_duplex", "", ""); set_widget_sensitive(builder, "ethernet_settings", FALSE); return; } set_label(builder, "ethernet_method", ethernet->method, ""); set_label(builder, "ethernet_interface", ethernet->interface, ""); set_label(builder, "ethernet_address", ethernet->address, ""); memset(value, 0, 6); snprintf(value, 6, "%u", ethernet->mtu); set_label(builder, "ethernet_mtu", value, ""); memset(value, 0, 6); snprintf(value, 6, "%u", ethernet->speed); set_label(builder, "ethernet_speed", value, ""); set_label(builder, "ethernet_duplex", ethernet->duplex, ""); set_widget_sensitive(builder, "ethernet_settings", TRUE); } static void service_property_changed_cb(const char *path, const char *property, void *user_data) { update_header(); } static void service_property_set_cb(const char *path, const char *property, void *user_data) { update_header(); update_ipv4(); update_ipv6(); update_dns(); update_timeservers(); update_proxy(); update_provider(); update_ethernet(); ipv4_changed = FALSE; ipv6_changed = FALSE; proxy_changed = FALSE; nameservers_changed = FALSE; domains_changed = FALSE; timeservers_changed = FALSE; connman_service_set_property_changed_callback(path, service_property_changed_cb, NULL); } static void service_property_error_cb(const char *path, const char *property, int error, void *user_data) { printf("Error setting %s (%d)\n", property, error); service_property_set_cb(NULL, NULL, NULL); } static void toggled_ipv4_method_cb(GtkToggleButton *togglebutton, gpointer user_data) { const char *name = user_data; gboolean enable_config = FALSE; if (gtk_toggle_button_get_active(togglebutton) == FALSE) return; if (g_strcmp0(name, "ipv4_manual") == 0) { ipv4_method = "manual"; enable_config = TRUE; } else if (g_strcmp0(name, "ipv4_dhcp") == 0) ipv4_method = "dhcp"; else ipv4_method = "off"; enable_ipv4_config(enable_config); ipv4_changed = TRUE; } static void toggled_ipv6_method_cb(GtkToggleButton *togglebutton, gpointer user_data) { const char *name = user_data; gboolean enable_config = FALSE; gboolean enable_privacy = FALSE; if (gtk_toggle_button_get_active(togglebutton) == FALSE) return; if (g_strcmp0(name, "ipv6_manual") == 0) { ipv6_method = "manual"; enable_config = TRUE; } else if (g_strcmp0(name, "ipv6_auto") == 0) { ipv6_method = "auto"; enable_privacy = TRUE; } else ipv6_method = "off"; enable_ipv6_config(enable_config); set_widget_sensitive(builder, "ipv6_priv_box", enable_privacy); ipv6_changed = TRUE; } static void toggled_ipv6_privacy_cb(GtkToggleButton *togglebutton, gpointer user_data) { const char *name = user_data; if (g_strcmp0(name, "ipv6_priv_enabled") == 0) ipv6_privacy = "enabled"; else if (g_strcmp0(name, "ipv6_priv_disabled") == 0) ipv6_privacy = "disabled"; else ipv6_privacy = "prefered"; ipv6_changed = TRUE; } static void toggled_proxy_method_cb(GtkToggleButton *togglebutton, gpointer user_data) { const char *name = user_data; gboolean enable_config = FALSE; if (gtk_toggle_button_get_active(togglebutton) == FALSE) return; if (g_strcmp0(name, "proxy_manual") == 0) { proxy_method = "manual"; enable_config = TRUE; } else if (g_strcmp0(name, "proxy_direct") == 0) proxy_method = "direct"; else proxy_method = "auto"; enable_proxy_config(enable_config); proxy_changed = TRUE; } static gboolean key_released_entry_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data) { gboolean *value = user_data; *value = TRUE; return TRUE; } static void get_ipv4_configuration(struct connman_ipv4 *ipv4) { ipv4->method = (char *) ipv4_method; ipv4->address = (char *) get_entry_text(builder, "ipv4_conf_address"); ipv4->netmask = (char *) get_entry_text(builder, "ipv4_conf_netmask"); ipv4->gateway = (char *) get_entry_text(builder, "ipv4_conf_gateway"); } static void get_ipv6_configuration(struct connman_ipv6 *ipv6) { const char *prefix; prefix = get_entry_text(builder, "ipv6_conf_prefix_length"); ipv6->method = (char *) ipv6_method; ipv6->address = (char *) get_entry_text(builder, "ipv6_conf_address"); ipv6->prefix = atoi(prefix); ipv6->gateway = (char *) get_entry_text(builder, "ipv6_conf_gateway"); ipv6->privacy = (char *) ipv6_privacy; } static void get_proxy_configuration(struct connman_proxy *proxy) { proxy->method = (char *) proxy_method; proxy->url = (char *) get_entry_text(builder, "proxy_conf_url"); proxy->servers = (char *) get_entry_text(builder, "proxy_conf_servers"); proxy->excludes = (char *) get_entry_text(builder, "proxy_conf_excludes"); } static void settings_cancel_callback(GtkButton *button, gpointer user_data) { gtk_widget_destroy(GTK_WIDGET(service_settings_dbox)); service_settings_dbox = NULL; connman_service_set_property_changed_callback(path, NULL, NULL); connman_service_set_property_error_callback(path, NULL, NULL); connman_service_deselect(); g_free(path); path = NULL; cui_tray_enable(); } static void settings_ok_callback(GtkButton *button, gpointer user_data) { const char *value; int ret = 0; connman_service_set_property_changed_callback(path, service_property_set_cb, NULL); if (ipv4_changed == TRUE) { struct connman_ipv4 ipv4; get_ipv4_configuration(&ipv4); ret = connman_service_set_ipv4_config(path, &ipv4); } else if (ipv6_changed == TRUE) { struct connman_ipv6 ipv6; get_ipv6_configuration(&ipv6); ret = connman_service_set_ipv6_config(path, &ipv6); } else if (proxy_changed == TRUE) { struct connman_proxy proxy; get_proxy_configuration(&proxy); ret = connman_service_set_proxy_config(path, &proxy); } else if (nameservers_changed == TRUE) { value = get_entry_text(builder, "nameservers_conf"); ret = connman_service_set_nameservers_config(path, value); } else if (domains_changed == TRUE) { value = get_entry_text(builder, "domains_conf"); ret = connman_service_set_domains_config(path, value); } else if (timeservers_changed == TRUE) { value = get_entry_text(builder, "timerservers_conf"); ret = connman_service_set_timeservers_config(path, value); } if (ret != 0) printf("Unable to set property, code %d\n", ret); } static void settings_close_callback(GtkDialog *dialog_box, gint response_id, gpointer user_data) { if (response_id == GTK_RESPONSE_DELETE_EVENT || response_id == GTK_RESPONSE_CLOSE) settings_cancel_callback(NULL, NULL); } static void settings_connect_signals(void) { set_signal_callback(builder, "ipv4_dhcp", "toggled", G_CALLBACK(toggled_ipv4_method_cb), "ipv4_dhcp"); set_signal_callback(builder, "ipv4_manual", "toggled", G_CALLBACK(toggled_ipv4_method_cb), "ipv4_manual"); set_signal_callback(builder, "ipv4_off", "toggled", G_CALLBACK(toggled_ipv4_method_cb), "ipv4_off"); set_signal_callback(builder, "ipv6_auto", "toggled", G_CALLBACK(toggled_ipv6_method_cb), "ipv6_auto"); set_signal_callback(builder, "ipv6_manual", "toggled", G_CALLBACK(toggled_ipv6_method_cb), "ipv6_manual"); set_signal_callback(builder, "ipv6_off", "toggled", G_CALLBACK(toggled_ipv6_method_cb), "ipv6_off"); set_signal_callback(builder, "ipv4_conf_address", "key-release-event", G_CALLBACK(key_released_entry_cb), &ipv4_changed); set_signal_callback(builder, "ipv4_conf_netmask", "key-release-event", G_CALLBACK(key_released_entry_cb), &ipv4_changed); set_signal_callback(builder, "ipv4_conf_gateway", "key-release-event", G_CALLBACK(key_released_entry_cb), &ipv4_changed); set_signal_callback(builder, "ipv6_conf_address", "key-release-event", G_CALLBACK(key_released_entry_cb), &ipv6_changed); set_signal_callback(builder, "ipv6_conf_prefix_length", "key-release-event", G_CALLBACK(key_released_entry_cb), &ipv6_changed); set_signal_callback(builder, "ipv6_conf_gateway", "key-release-event", G_CALLBACK(key_released_entry_cb), &ipv6_changed); set_signal_callback(builder, "ipv6_priv_prefered", "toggled", G_CALLBACK(toggled_ipv6_privacy_cb), "ipv6_priv_prefered"); set_signal_callback(builder, "ipv6_priv_enabled", "toggled", G_CALLBACK(toggled_ipv6_privacy_cb), "ipv6_priv_enabled"); set_signal_callback(builder, "ipv6_priv_disabled", "toggled", G_CALLBACK(toggled_ipv6_privacy_cb), "ipv6_priv_disabled"); set_signal_callback(builder, "nameservers_conf", "key-release-event", G_CALLBACK(key_released_entry_cb), &nameservers_changed); set_signal_callback(builder, "domains_conf", "key-release-event", G_CALLBACK(key_released_entry_cb), &domains_changed); set_signal_callback(builder, "timerservers_conf", "key-release-event", G_CALLBACK(key_released_entry_cb), ×ervers_changed); set_signal_callback(builder, "proxy_auto", "toggled", G_CALLBACK(toggled_proxy_method_cb), "proxy_auto"); set_signal_callback(builder, "proxy_direct", "toggled", G_CALLBACK(toggled_proxy_method_cb), "proxy_direct"); set_signal_callback(builder, "proxy_manual", "toggled", G_CALLBACK(toggled_proxy_method_cb), "proxy_manual"); set_signal_callback(builder, "proxy_conf_url", "key-release-event", G_CALLBACK(key_released_entry_cb), &proxy_changed); set_signal_callback(builder, "proxy_conf_servers", "key-release-event", G_CALLBACK(key_released_entry_cb), &proxy_changed); set_signal_callback(builder, "proxy_conf_excludes", "key-release-event", G_CALLBACK(key_released_entry_cb), &proxy_changed); set_signal_callback(builder, "settings_ok", "clicked", G_CALLBACK(settings_ok_callback), NULL); set_signal_callback(builder, "settings_close", "clicked", G_CALLBACK(settings_cancel_callback), NULL); set_signal_callback(builder, "service_settings_dbox", "response", G_CALLBACK(settings_close_callback), NULL); } gint cui_settings_popup(const char *selected_path) { GError *error = NULL; if (builder == NULL) builder = gtk_builder_new(); if (builder == NULL) return -ENOMEM; gtk_builder_add_from_file(builder, CUI_SETTINGS_UI_PATH, &error); if (error != NULL) { printf("Error: %s\n", error->message); g_error_free(error); return -EINVAL; } connman_service_select(selected_path); g_free(path); path = g_strdup(selected_path); service_settings_dbox = (GtkDialog *) gtk_builder_get_object(builder, "service_settings_dbox"); gtk_widget_show(GTK_WIDGET(service_settings_dbox)); connman_service_set_property_changed_callback(path, service_property_changed_cb, NULL); connman_service_set_property_error_callback(path, service_property_error_cb, NULL); settings_connect_signals(); /* Force UI update */ service_property_set_cb(NULL, NULL, NULL); cui_tray_disable(); return 0; } connman-ui-0_20150622+dfsg.orig/src/right-menu.c0000644000175000017500000001302312541725135017566 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #define CUI_RIGHT_MENU_UI_PATH CUI_UI_PATH "/right_menu.ui" static GtkMenu *cui_right_menu = NULL; static GtkWidget *cui_item_mode_off = NULL; static GtkWidget *cui_item_mode_on = NULL; static GtkMenu *cui_tethering_menu = NULL; static GHashTable *tech_items = NULL; static int item_position = 3; static gboolean disabled = TRUE; static void add_technology(const char *path) { GtkTechnology *t; t = gtk_technology_new(path); gtk_menu_shell_insert(GTK_MENU_SHELL(cui_right_menu), (GtkWidget *)t, item_position); item_position++; gtk_widget_set_visible((GtkWidget *)t, TRUE); gtk_widget_show((GtkWidget *)t); gtk_menu_shell_append(GTK_MENU_SHELL(cui_tethering_menu), (GtkWidget *)gtk_technology_get_tethering_item(t)); g_hash_table_insert(tech_items, t->path, t); } static void technology_added_cb(const char *path) { add_technology(path); } static void technology_removed_cb(const char *path) { g_hash_table_remove(tech_items, path); } static void delete_technology_item(gpointer data) { GtkWidget *item = data; gtk_widget_destroy(item); item_position--; } static void cui_item_offlinemode_activate(GtkMenuItem *menuitem, gpointer user_data) { gboolean offlinemode; offlinemode = !connman_manager_get_offlinemode(); connman_manager_set_offlinemode(offlinemode); } static void cui_item_quit_activate(GtkMenuItem *menuitem, gpointer user_data) { gtk_main_quit(); } static void cui_popup_right_menu(GtkStatusIcon *trayicon, guint button, guint activate_time, gpointer user_data) { GList *tech_list, *list; if (disabled == TRUE) goto popup; if (connman_manager_get_offlinemode()) { gtk_widget_show(cui_item_mode_on); gtk_widget_hide(cui_item_mode_off); } else { gtk_widget_show(cui_item_mode_off); gtk_widget_hide(cui_item_mode_on); } tech_list = connman_technology_get_technologies(); if (tech_list == NULL) goto popup; for (list = tech_list; list != NULL; list = list->next) add_technology((const char *)list->data); g_list_free(tech_list); popup: connman_technology_set_removed_callback(technology_removed_cb); connman_technology_set_added_callback(technology_added_cb); gtk_menu_popup(cui_right_menu, NULL, NULL, NULL, NULL, button, activate_time); } static void cui_popdown_right_menu(GtkMenu *menu, gpointer user_data) { connman_technology_set_removed_callback(NULL); connman_technology_set_added_callback(NULL); g_hash_table_remove_all(tech_items); } static void cui_enable_item(gboolean enable) { set_widget_hidden(cui_builder, "cui_item_offlinemode_on", enable); set_widget_hidden(cui_builder, "cui_item_offlinemode_off", enable); set_widget_hidden(cui_builder, "cui_sep_technology_up", enable); set_widget_hidden(cui_builder, "cui_sep_technology_down", enable); set_widget_hidden(cui_builder, "cui_item_tethering", enable); set_widget_hidden(cui_builder, "cui_sep_tethering", enable); set_widget_hidden(cui_builder, "cui_item_quit", FALSE); disabled = enable; } void cui_right_menu_enable_only_quit(void) { cui_enable_item(TRUE); } void cui_right_menu_enable_all(void) { cui_enable_item(FALSE); } gint cui_load_right_menu(GtkBuilder *builder, GtkStatusIcon *trayicon) { GtkImageMenuItem *cui_item_tethering; GtkMenuItem *cui_item_quit; GdkPixbuf *image = NULL; GError *error = NULL; gtk_builder_add_from_file(builder, CUI_RIGHT_MENU_UI_PATH, &error); if (error != NULL) { printf("Error: %s\n", error->message); g_error_free(error); return -EINVAL; } cui_builder = builder; cui_right_menu = (GtkMenu *) gtk_builder_get_object(builder, "cui_right_menu"); cui_item_quit = (GtkMenuItem *) gtk_builder_get_object(builder, "cui_item_quit"); cui_item_mode_off = (GtkWidget *) gtk_builder_get_object(builder, "cui_item_offlinemode_off"); cui_item_mode_on = (GtkWidget *) gtk_builder_get_object(builder, "cui_item_offlinemode_on"); cui_tethering_menu = (GtkMenu *) gtk_builder_get_object(builder, "cui_tethering_menu"); g_signal_connect(cui_right_menu, "deactivate", G_CALLBACK(cui_popdown_right_menu), NULL); g_signal_connect(cui_item_quit, "activate", G_CALLBACK(cui_item_quit_activate), NULL); g_signal_connect(cui_item_mode_off, "activate", G_CALLBACK(cui_item_offlinemode_activate), NULL); g_signal_connect(cui_item_mode_on, "activate", G_CALLBACK(cui_item_offlinemode_activate), NULL); tech_items = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, delete_technology_item); cui_item_tethering = (GtkImageMenuItem *) gtk_builder_get_object( builder, "cui_item_tethering"); cui_theme_get_tethering_icone_and_info(&image, NULL); if (image != NULL) gtk_image_menu_item_set_image(cui_item_tethering, gtk_image_new_from_pixbuf(image)); cui_tray_hook_right_menu(cui_popup_right_menu); return 0; } connman-ui-0_20150622+dfsg.orig/src/theme.c0000644000175000017500000000673012541725135016620 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include static GtkIconTheme *icon_theme = NULL; void cui_theme_get_tethering_icone_and_info(GdkPixbuf **image, const char **info) { if (image != NULL) *image = gtk_icon_theme_load_icon(icon_theme, "nm-adhoc", 24, 0, NULL); if (info != NULL) *info = _("Tethering"); } void cui_theme_get_type_icone_and_info(const char *type, GdkPixbuf **image, const char **info) { const char *nfo = NULL; GdkPixbuf *img = NULL; if (g_strcmp0(type, "ethernet") == 0) { img = gtk_icon_theme_load_icon(icon_theme, "network-wired-symbolic", 22, 0, NULL); nfo = _("Ethernet"); } else if (g_strcmp0(type, "cellular") == 0) { img = gtk_icon_theme_load_icon(icon_theme, "gsm-3g-full", 22, 0, NULL); nfo = _("Cellular"); } if (image != NULL) *image = img; if (info != NULL) *info = nfo; } void cui_theme_get_signal_icone_and_info(uint8_t signal_strength, GdkPixbuf **image, const char **info) { const char *nfo; GdkPixbuf *img; if (signal_strength >= 80) { img = gtk_icon_theme_load_icon(icon_theme, "network-wireless-signal-excellent-symbolic", 22, 0, NULL); nfo = _("Very good signal"); } else if (signal_strength >= 60 && signal_strength < 80) { img = gtk_icon_theme_load_icon(icon_theme, "network-wireless-signal-good-symbolic", 22, 0, NULL); nfo = _("Good signal"); } else if (signal_strength >= 40 && signal_strength < 60) { img = gtk_icon_theme_load_icon(icon_theme, "network-wireless-signal-ok-symbolic", 22, 0, NULL); nfo = _("Low signal"); } else { img = gtk_icon_theme_load_icon(icon_theme, "network-wireless-signal-weak-symbolic", 22, 0, NULL); nfo = _("Very low signal"); } if (image != NULL) *image = img; if (info != NULL) *info = nfo; } void cui_theme_get_state_icone_and_info(enum connman_state state, GdkPixbuf **image, const char **info) { const char *nfo = NULL; GdkPixbuf *img = NULL; switch (state) { case CONNMAN_STATE_UNKNOWN: img = gtk_icon_theme_load_icon(icon_theme, "network-offline-symbolic", 24, 0, NULL); nfo = _("Connman is not running"); break; case CONNMAN_STATE_READY: img = gtk_icon_theme_load_icon(icon_theme, "network-idle-symbolic", 24, 0, NULL); nfo = _("Connected"); break; case CONNMAN_STATE_ONLINE: img = gtk_icon_theme_load_icon(icon_theme, "network-transmit-receive-symbolic", 24, 0, NULL); nfo = _("Online"); break; default: img = gtk_icon_theme_load_icon(icon_theme, "network-offline-symbolic", 24, 0, NULL); nfo = _("Disconnected"); break; } if (image != NULL) *image = img; if (info != NULL) *info = nfo; } void cui_load_theme(void) { icon_theme = gtk_icon_theme_get_default (); gtk_icon_theme_append_search_path(icon_theme, CUI_ICON_PATH); } connman-ui-0_20150622+dfsg.orig/src/connman-ui-gtk.h0000644000175000017500000000610712541725135020350 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef __CONNMAN_UI_GTK_H__ #define __CONNMAN_UI_GTK_H__ #include #include #include #include #include #include #include #include struct cui_selected_service { char *path; char *name; }; extern GtkBuilder *cui_builder; void cui_load_theme(void); void cui_theme_get_type_icone_and_info(const char *type, GdkPixbuf **image, const char **info); void cui_theme_get_signal_icone_and_info(uint8_t signal_strength, GdkPixbuf **image, const char **info); void cui_theme_get_state_icone_and_info(enum connman_state state, GdkPixbuf **image, const char **info); void cui_theme_get_tethering_icone_and_info(GdkPixbuf **image, const char **info); gint cui_load_trayicon(GtkBuilder *builder); void cui_trayicon_update_icon(void); void cui_tray_hook_left_menu(gpointer callback); void cui_tray_hook_right_menu(gpointer callback); void cui_tray_left_menu_disable(void); void cui_tray_enable(void); void cui_tray_disable(void); gint cui_load_agent_dialogs(void); void cui_agent_init_callbacks(void); void cui_agent_set_selected_service(const char *path, const char *name); void cui_agent_set_wifi_tethering_settings(const char *path, gboolean tether); gint cui_load_left_menu(GtkBuilder *builder, GtkStatusIcon *trayicon); gint cui_load_right_menu(GtkBuilder *builder, GtkStatusIcon *trayicon); void cui_right_menu_enable_only_quit(void); void cui_right_menu_enable_all(void); gint cui_settings_popup(const char *path); GtkLabel *set_label(GtkBuilder *builder, const char *name, const char *value, const char *default_value); GtkEntry *set_entry(GtkBuilder *builder, const char *name, const char *value, const char *default_value); GtkWidget *set_widget_sensitive(GtkBuilder *builder, const char *name, gboolean value); GtkWidget *set_widget_hidden(GtkBuilder *builder, const char *name, gboolean value); GtkWidget *set_button_toggle(GtkBuilder *builder, const char *name, gboolean active); GtkImage *set_image(GtkBuilder *builder, const char *name, GdkPixbuf *image, const char *info); void set_signal_callback(GtkBuilder *builder, const char *name, const char *signal_name, GCallback handler, gpointer user_data); const char *get_entry_text(GtkBuilder *builder, const char *name); #endif /* __CONNMAN_UI_GTK_H__ */ connman-ui-0_20150622+dfsg.orig/src/gtkservice.c0000644000175000017500000001763512541725135017672 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include struct _GtkServicePrivate { GtkBox *box; GtkLabel *name; GtkImage *state; GtkImage *security; GtkImage *signal; gboolean selected; }; static void gtk_service_destroy(GtkWidget *widget); static void gtk_service_class_init(GtkServiceClass *klass); static void gtk_service_init(GtkService *service); static void gtk_service_dispose(GObject *object); static gboolean gtk_service_button_release_event(GtkWidget *widget, GdkEventButton *event); G_DEFINE_TYPE(GtkService, gtk_service, GTK_TYPE_MENU_ITEM); static void gtk_service_class_init(GtkServiceClass *klass) { GObjectClass *object_class; GtkWidgetClass *widget_class; GtkMenuItemClass *menu_item_class; object_class = G_OBJECT_CLASS(klass); widget_class = GTK_WIDGET_CLASS(klass); menu_item_class = GTK_MENU_ITEM_CLASS(klass); object_class->dispose = gtk_service_dispose; widget_class->destroy = gtk_service_destroy; widget_class->button_release_event = gtk_service_button_release_event; menu_item_class->hide_on_activate = FALSE; g_type_class_add_private(object_class, sizeof(GtkServicePrivate)); } static void gtk_service_init(GtkService *service) { GtkServicePrivate *priv; priv = G_TYPE_INSTANCE_GET_PRIVATE(service, GTK_TYPE_SERVICE, GtkServicePrivate); service->priv = priv; priv->box = (GtkBox *) gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10); priv->name = (GtkLabel *) gtk_label_new(NULL); priv->state = (GtkImage *) gtk_image_new(); priv->security = (GtkImage *) gtk_image_new(); priv->signal = (GtkImage *) gtk_image_new(); priv->selected = FALSE; //gtk_widget_set_halign((GtkWidget *)priv->box, GTK_ALIGN_START); gtk_widget_set_halign((GtkWidget *)priv->name, GTK_ALIGN_START); gtk_widget_set_halign((GtkWidget *)priv->state, GTK_ALIGN_END); gtk_widget_set_halign((GtkWidget *)priv->security, GTK_ALIGN_END); gtk_widget_set_halign((GtkWidget *)priv->signal, GTK_ALIGN_END); gtk_box_set_homogeneous(priv->box, FALSE); gtk_box_pack_start(priv->box, (GtkWidget *)priv->name, TRUE, TRUE, 0); gtk_box_pack_start(priv->box, (GtkWidget *) priv->state, TRUE, TRUE, 0); gtk_box_pack_start(priv->box, (GtkWidget *) priv->security, TRUE, TRUE, 0); gtk_box_pack_start(priv->box, (GtkWidget *) priv->signal, TRUE, TRUE, 0); gtk_widget_set_visible((GtkWidget *)priv->box, TRUE); gtk_widget_set_visible((GtkWidget *)priv->name, TRUE); gtk_widget_set_visible((GtkWidget *)priv->state, FALSE); gtk_widget_set_visible((GtkWidget *)priv->security, FALSE); gtk_widget_set_visible((GtkWidget *)priv->signal, FALSE); gtk_container_add(GTK_CONTAINER(service), (GtkWidget *)priv->box); gtk_widget_set_can_focus((GtkWidget *)priv->box, TRUE); } static void gtk_service_dispose(GObject *object) { (*G_OBJECT_CLASS(gtk_service_parent_class)->dispose)(object); } static void gtk_service_destroy(GtkWidget *widget) { GtkService *service = GTK_SERVICE(widget); GtkServicePrivate *priv = service->priv; if (priv != NULL && priv->selected == FALSE) { connman_service_set_property_changed_callback(service->path, NULL, service); connman_technology_set_property_error_callback(service->path, NULL, service); } GTK_WIDGET_CLASS(gtk_service_parent_class)->destroy(widget); } static gboolean gtk_service_button_release_event(GtkWidget *widget, GdkEventButton *event) { GtkService *service = GTK_SERVICE(widget); GtkWidget *parent; if (event->button != 1 && event->button != 3) goto activate; if (event->button == 1) { if (connman_service_is_connected(service->path) == TRUE) connman_service_disconnect(service->path); else { cui_agent_set_selected_service(service->path, connman_service_get_name(service->path)); connman_service_connect(service->path); } } else if (event->button == 3) { service->priv->selected = TRUE; cui_settings_popup(service->path); } activate: parent = gtk_widget_get_parent (widget); if (parent != NULL && GTK_IS_MENU_SHELL(parent) == TRUE) { GtkMenuShell *menu_shell = GTK_MENU_SHELL(parent); gtk_menu_shell_activate_item(menu_shell, widget, TRUE); } return TRUE; } static void service_property_changed_cb(const char *path, const char *property, void *user_data) { return; } static void service_set_state(GtkService *service) { GtkServicePrivate *priv = service->priv; const struct connman_ipv4 *ipv4; enum connman_state state; GdkPixbuf *image = NULL; const char *ip = NULL; const char *info; if (connman_service_is_connected(service->path) == FALSE) { gtk_widget_set_tooltip_text((GtkWidget *)priv->name, ""); return; } ipv4 = connman_service_get_ipv4(service->path); if (ipv4 == NULL) { const struct connman_ipv6 *ipv6; ipv6 = connman_service_get_ipv6(service->path); if (ipv6 != NULL) ip = ipv6->address; } else ip = ipv4->address; if (ip == NULL) ip = ""; gtk_widget_set_tooltip_text((GtkWidget *)priv->name, ip); state = connman_service_get_state(service->path); cui_theme_get_state_icone_and_info(state, &image, &info); if (image == NULL) return; gtk_widget_set_visible((GtkWidget *)priv->state, TRUE); gtk_widget_set_tooltip_text((GtkWidget *)priv->state, info); gtk_image_set_from_pixbuf(priv->state, image); } static void service_set_signal(GtkService *service) { GtkServicePrivate *priv = service->priv; GdkPixbuf *image = NULL; const char *type, *info; type = connman_service_get_type(service->path); if (g_strcmp0(type, "wifi") == 0) { uint8_t strength; strength = connman_service_get_strength(service->path); cui_theme_get_signal_icone_and_info(strength, &image, &info); } else cui_theme_get_type_icone_and_info(type, &image, &info); if (image == NULL) return; gtk_widget_set_visible((GtkWidget *)priv->signal, TRUE); gtk_widget_set_tooltip_text((GtkWidget *)priv->signal, info); gtk_image_set_from_pixbuf(priv->signal, image); } static void service_set_name(GtkService *service) { const char *name; char *markup; name = connman_service_get_name(service->path); if (name == NULL) name = "- Hidden -"; if (connman_service_is_favorite(service->path) == TRUE) { if (g_strcmp0(connman_service_get_type(service->path), "wifi") == 0) { markup = g_markup_printf_escaped( "%s (%s) ", name, connman_service_get_security(service->path)); } else markup = g_markup_printf_escaped("%s", name); } else { if (g_strcmp0(connman_service_get_type(service->path), "wifi") == 0) { markup = g_markup_printf_escaped( "%s (%s) ", name, connman_service_get_security(service->path)); } else markup = g_markup_printf_escaped("%s", name); } gtk_label_set_markup(service->priv->name, markup); g_free(markup); } GtkService *gtk_service_new(const char *path) { GtkService *service; char *path_copy; if (path == NULL) return NULL; path_copy = g_strdup(path); if (path_copy == NULL) return NULL; service = g_object_new(GTK_TYPE_SERVICE, NULL); if (service == NULL) { g_free(path_copy); return NULL; } service->path = path_copy; connman_service_set_property_changed_callback(path_copy, service_property_changed_cb, service); service_set_name(service); service_set_state(service); service_set_signal(service); return service; } connman-ui-0_20150622+dfsg.orig/src/main.c0000644000175000017500000000447312541725135016444 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include GtkBuilder *cui_builder; static void connman_manager_changed(const char *unused, const char *property, void *user_data) { if (g_strcmp0(property, "State") == 0) cui_trayicon_update_icon(); } static void connman_up(void *user_data) { connman_manager_init(connman_manager_changed, NULL); connman_service_init(); connman_technology_init(); connman_agent_init(); cui_agent_init_callbacks(); cui_trayicon_update_icon(); cui_tray_enable(); cui_right_menu_enable_all(); } static void connman_down(void *user_data) { connman_agent_finalize(); connman_service_finalize(); connman_technology_finalize(); connman_manager_finalize(); cui_trayicon_update_icon(); cui_tray_left_menu_disable(); cui_right_menu_enable_only_quit(); } int main(int argc, char *argv[]) { int ret; setlocale(LC_ALL, ""); bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); printf("%s\n", GETTEXT_PACKAGE); gtk_init(&argc, &argv); cui_builder = gtk_builder_new(); if (cui_builder == NULL) return -ENOMEM; cui_load_theme(); if (cui_load_trayicon(cui_builder) != 0) return -EINVAL; if (cui_load_agent_dialogs() != 0) return -EINVAL; cui_tray_enable(); ret = connman_interface_init(connman_up, connman_down, NULL); if (ret < 0) return ret; gtk_main(); connman_agent_finalize(); connman_service_finalize(); connman_technology_finalize(); connman_manager_finalize(); connman_interface_finalize(); return 0; } connman-ui-0_20150622+dfsg.orig/src/utils.c0000644000175000017500000000654312541725135016660 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include GtkLabel *set_label(GtkBuilder *builder, const char *name, const char *value, const char *default_value) { GtkLabel *label; label = (GtkLabel *) gtk_builder_get_object(builder, name); if (label == NULL) return NULL; if (value == NULL) value = default_value; gtk_label_set_text(label, value); return label; } GtkEntry *set_entry(GtkBuilder *builder, const char *name, const char *value, const char *default_value) { GtkEntry *entry; entry = (GtkEntry *) gtk_builder_get_object(builder, name); if (entry == NULL) return NULL; if (value == NULL) value = default_value; gtk_entry_set_text(entry, value); return entry; } GtkWidget *set_widget_sensitive(GtkBuilder *builder, const char *name, gboolean value) { GtkWidget *widget; widget = (GtkWidget *) gtk_builder_get_object(builder, name); if (widget == NULL) return NULL; gtk_widget_set_sensitive(widget, value); return widget; } GtkWidget *set_widget_hidden(GtkBuilder *builder, const char *name, gboolean value) { GtkWidget *widget; widget = (GtkWidget *) gtk_builder_get_object(builder, name); if (widget == NULL) return NULL; gtk_widget_set_visible(widget, value); if (value == TRUE) gtk_widget_hide(widget); else gtk_widget_show(widget); return widget; } GtkWidget *set_button_toggle(GtkBuilder *builder, const char *name, gboolean active) { GtkWidget *widget; widget = (GtkWidget *) gtk_builder_get_object(builder, name); if (widget == NULL) return NULL; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), active); return widget; } GtkImage *set_image(GtkBuilder *builder, const char *name, GdkPixbuf *image, const char *info) { GtkImage *img_widget; img_widget = (GtkImage *) gtk_builder_get_object(builder, name); if (img_widget == NULL) return NULL; if (image != NULL) { gtk_widget_set_visible(GTK_WIDGET(img_widget), TRUE); gtk_widget_set_tooltip_text(GTK_WIDGET(img_widget), info); gtk_image_set_from_pixbuf(img_widget, image); } else gtk_widget_set_visible(GTK_WIDGET(img_widget), FALSE); return img_widget; } void set_signal_callback(GtkBuilder *builder, const char *name, const char *signal_name, GCallback handler, gpointer user_data) { GtkWidget *widget; widget = (GtkWidget *) gtk_builder_get_object(builder, name); if (widget == NULL) return; g_signal_connect(widget, signal_name, handler, user_data); } const char *get_entry_text(GtkBuilder *builder, const char *name) { GtkEntry *entry; entry = (GtkEntry *) gtk_builder_get_object(builder, name); if (entry == NULL) return NULL; return gtk_entry_get_text(entry); } connman-ui-0_20150622+dfsg.orig/src/gtktechnology.c0000644000175000017500000002145312541725135020376 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include struct _GtkTechnologyPrivate { GtkBox *box; GtkSwitch *enabler; GtkLabel *name; GtkCheckMenuItem *tethering; }; static void gtk_technology_destroy(GtkWidget *widget); static void gtk_technology_class_init(GtkTechnologyClass *klass); static void gtk_technology_init(GtkTechnology *technology); static void gtk_technology_dispose(GObject *object); static gboolean gtk_technology_button_release_event(GtkWidget *widget, GdkEventButton *event); G_DEFINE_TYPE(GtkTechnology, gtk_technology, GTK_TYPE_MENU_ITEM); static void gtk_technology_class_init(GtkTechnologyClass *klass) { GObjectClass *object_class; GtkWidgetClass *widget_class; GtkMenuItemClass *menu_item_class; object_class = G_OBJECT_CLASS(klass); widget_class = GTK_WIDGET_CLASS(klass); menu_item_class = GTK_MENU_ITEM_CLASS(klass); object_class->dispose = gtk_technology_dispose; widget_class->destroy = gtk_technology_destroy; widget_class->button_release_event = gtk_technology_button_release_event; menu_item_class->hide_on_activate = FALSE; g_type_class_add_private(object_class, sizeof(GtkTechnologyPrivate)); } static void gtk_technology_init(GtkTechnology *technology) { GtkTechnologyPrivate *priv; priv = G_TYPE_INSTANCE_GET_PRIVATE(technology, GTK_TYPE_TECHNOLOGY, GtkTechnologyPrivate); technology->priv = priv; priv->box = (GtkBox *) gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); priv->enabler = (GtkSwitch *) gtk_switch_new(); priv->name = (GtkLabel *) gtk_label_new(NULL); gtk_widget_set_margin_start((GtkWidget *)priv->enabler, 0); gtk_widget_set_margin_end((GtkWidget *)priv->enabler, 0); gtk_widget_set_margin_top((GtkWidget *)priv->enabler, 0); gtk_widget_set_margin_bottom((GtkWidget *)priv->enabler, 0); gtk_widget_set_margin_start((GtkWidget *)priv->name, 0); gtk_widget_set_margin_end((GtkWidget *)priv->name, 0); gtk_widget_set_margin_top((GtkWidget *)priv->name, 0); gtk_widget_set_margin_bottom((GtkWidget *)priv->name, 0); gtk_box_set_spacing(priv->box, 0); gtk_box_set_homogeneous(priv->box, TRUE); //gtk_widget_set_halign((GtkWidget *)priv->box, GTK_ALIGN_START); gtk_widget_set_halign((GtkWidget *)priv->name, GTK_ALIGN_START); //gtk_widget_set_halign((GtkWidget *)technology, GTK_ALIGN_START); gtk_box_pack_start(priv->box, (GtkWidget *)priv->enabler, FALSE, FALSE, 0); gtk_box_pack_start(priv->box, (GtkWidget *)priv->name, FALSE, FALSE, 0); gtk_widget_set_visible((GtkWidget *)priv->box, TRUE); gtk_widget_set_visible((GtkWidget *)priv->enabler, TRUE); gtk_widget_set_visible((GtkWidget *)priv->name, TRUE); gtk_container_add(GTK_CONTAINER(technology), (GtkWidget *)priv->box); gtk_widget_set_can_focus((GtkWidget *)priv->box, TRUE); gtk_widget_set_can_focus((GtkWidget *)priv->enabler, TRUE); } static void gtk_technology_dispose(GObject *object) { (*G_OBJECT_CLASS(gtk_technology_parent_class)->dispose)(object); } static void gtk_technology_destroy(GtkWidget *widget) { GtkTechnology *technology = GTK_TECHNOLOGY(widget); GtkTechnologyPrivate *priv = technology->priv; connman_technology_set_property_changed_callback(technology->path, NULL, technology); connman_technology_set_property_error_callback(technology->path, NULL, technology); if (priv->tethering != NULL) { gtk_widget_destroy((GtkWidget *)priv->tethering); priv->tethering = NULL; } GTK_WIDGET_CLASS(gtk_technology_parent_class)->destroy(widget); } static gboolean gtk_technology_button_release_event(GtkWidget *widget, GdkEventButton *event) { GtkTechnology *technology = GTK_TECHNOLOGY(widget); GtkTechnologyPrivate *priv = technology->priv; gboolean enable; if (event->button != 1 && event->button != 3) return TRUE; if (event->button == 3) { GtkWidget *parent; const char *type; type = connman_technology_get_type(technology->path); if (g_strcmp0(type, "wifi") == 0) cui_agent_set_wifi_tethering_settings(technology->path, FALSE); parent = gtk_widget_get_parent (widget); if (parent != NULL && GTK_IS_MENU_SHELL(parent) == TRUE) { GtkMenuShell *menu_shell = GTK_MENU_SHELL(parent); gtk_menu_shell_activate_item(menu_shell, widget, TRUE); } return TRUE; } enable = !gtk_switch_get_active(priv->enabler); if (connman_technology_enable(technology->path, enable) == 0) gtk_widget_set_sensitive((GtkWidget *)priv->enabler, FALSE); return TRUE; } static void technology_property_error_cb(const char *path, const char *property, int error, void *user_data) { if (error != 0) printf("Could not set property %s\n", property); } static gboolean gtk_technology_tethering_button(GtkWidget *widget, GdkEventButton *event, gpointer user_data) { GtkTechnology *technology = user_data; GtkTechnologyPrivate *priv = technology->priv; gboolean tethering; if (event->button != 1) return TRUE; gtk_widget_set_sensitive((GtkWidget *)priv->tethering, FALSE); tethering = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), !tethering); connman_technology_tether(technology->path, !tethering); return TRUE; } static void set_technology_name(GtkTechnology *technology, gboolean enabled) { const char *name = connman_technology_get_name(technology->path); if (enabled == TRUE) { char *markup; markup = g_markup_printf_escaped("%s", name); gtk_label_set_markup(technology->priv->name, markup); g_free(markup); } else gtk_label_set_text(technology->priv->name, name); } static void technology_property_changed_cb(const char *path, const char *property, void *user_data) { GtkTechnology *technology = user_data; GtkTechnologyPrivate *priv = technology->priv; if (g_strcmp0(property, "Powered") == 0) { gboolean enabled; enabled = connman_technology_is_enabled(path); gtk_switch_set_active(priv->enabler, enabled); gtk_widget_set_sensitive((GtkWidget *)priv->enabler, TRUE); gtk_widget_set_sensitive((GtkWidget *)priv->tethering, enabled); set_technology_name(technology, enabled); } else if (g_strcmp0(property, "Tethering") == 0) { gtk_check_menu_item_set_active(priv->tethering, connman_technology_is_tethering(path)); gtk_widget_set_sensitive((GtkWidget *)priv->tethering, connman_technology_is_enabled(path)); } } GtkTechnology *gtk_technology_new(const gchar *path) { GtkTechnology *technology; GtkTechnologyPrivate *priv; gchar *path_copy, *label; gboolean enabled; if (path == NULL) return NULL; path_copy = g_strdup(path); if (path_copy == NULL) return NULL; technology = g_object_new(GTK_TYPE_TECHNOLOGY, NULL); if (technology == NULL) { g_free(path_copy); return NULL; } priv = technology->priv; technology->path = path_copy; connman_technology_set_property_changed_callback(path_copy, technology_property_changed_cb, technology); connman_technology_set_property_error_callback(technology->path, technology_property_error_cb, technology); if (g_strcmp0(connman_technology_get_type(path_copy), "wifi") == 0) { gtk_widget_set_tooltip_text(GTK_WIDGET(technology), _("Left click to enable/disable\n" "Right click to set tethering information")); } else gtk_widget_set_tooltip_text(GTK_WIDGET(technology), _("Left to enable/disable")); enabled = connman_technology_is_enabled(path_copy); gtk_switch_set_active(priv->enabler, enabled); label = g_strdup_printf("via: %s", connman_technology_get_name(path_copy)); priv->tethering = (GtkCheckMenuItem *) gtk_check_menu_item_new_with_label(label); if (enabled == FALSE) gtk_widget_set_sensitive((GtkWidget *)priv->tethering, FALSE); set_technology_name(technology, enabled); gtk_check_menu_item_set_active(priv->tethering, connman_technology_is_tethering(path_copy)); gtk_widget_set_visible((GtkWidget *)priv->tethering, TRUE); g_signal_connect(priv->tethering, "button-release-event", G_CALLBACK(gtk_technology_tethering_button), technology); return technology; } GtkMenuItem *gtk_technology_get_tethering_item(GtkTechnology *technology) { GtkTechnologyPrivate *priv = technology->priv; return GTK_MENU_ITEM(priv->tethering); } connman-ui-0_20150622+dfsg.orig/src/agent_dialogs.c0000644000175000017500000003512112541725135020312 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #define CUI_AGENT_DIALOG_UI_PATH CUI_UI_PATH "/agent.ui" static GtkDialog *input_dbox = NULL; static GtkDialog *login_dbox = NULL; static GtkDialog *error_dbox = NULL; static GtkDialog *tethering_dbox = NULL; static struct cui_selected_service service; static char *technology = NULL; static gboolean tethering = FALSE; static void agent_popup_error_dbox(const char *error) { GtkLabel *label; label = (GtkLabel *)gtk_builder_get_object(cui_builder, "error_message"); gtk_label_set_text(label, error); gtk_widget_show(GTK_WIDGET(error_dbox)); cui_tray_disable(); } static void agent_error_cb(const char *path, const char *error) { agent_popup_error_dbox(error); } static void agent_browser_cb(const char *path, const char *url) { return; } static void agent_popup_input_dbox(gboolean hidden, gboolean passphrase, const char *previous_passphrase, gboolean wpspin, const char *previous_wpspin) { GtkToggleButton *button; gchar *previous_value; GtkLabel *label; GtkEntry *entry; set_label(cui_builder, "service_label", service.name, ""); /* Hidden settings */ button = (GtkToggleButton *) gtk_builder_get_object(cui_builder, "name_button"); gtk_widget_set_visible(GTK_WIDGET(button), hidden); button = (GtkToggleButton *) gtk_builder_get_object(cui_builder, "ssid_button"); gtk_widget_set_visible(GTK_WIDGET(button), hidden); entry = (GtkEntry *) gtk_builder_get_object(cui_builder, "hidden_entry"); gtk_widget_set_visible((GtkWidget *)entry, hidden); gtk_entry_set_text(entry, ""); /* Passphrase/WPS settings */ button = (GtkToggleButton *)gtk_builder_get_object(cui_builder, "passphrase_button"); gtk_toggle_button_set_active(button, TRUE); entry = (GtkEntry *)gtk_builder_get_object(cui_builder, "secret_entry"); gtk_entry_set_text(entry, ""); gtk_entry_set_visibility(entry, FALSE); set_widget_sensitive(cui_builder, "input_ok", FALSE); /* Setting WPS part */ button = (GtkToggleButton *)gtk_builder_get_object(cui_builder, "wpspbc_button"); gtk_widget_set_visible(GTK_WIDGET(button), wpspin); gtk_toggle_button_set_active(button, FALSE); button = (GtkToggleButton *)gtk_builder_get_object(cui_builder, "wpspin_button"); gtk_widget_set_visible(GTK_WIDGET(button), FALSE); /* Disabling PIN */ gtk_toggle_button_set_active(button, FALSE); label = (GtkLabel *)gtk_builder_get_object(cui_builder, "previous_label"); gtk_widget_set_visible(GTK_WIDGET(label), TRUE); if (previous_passphrase != NULL) { previous_value = g_strdup_printf(_("Previous Passphrase:\n%s"), previous_passphrase); gtk_label_set_text(label, previous_value); }/* else if (previous_wpspin != NULL) { previous_value = g_strdup_printf(_("Previous WPS PIN:\n%s"), previous_wpspin); gtk_label_set_text(label, previous_value); }*/ else { gtk_label_set_text(label, ""); gtk_widget_set_visible(GTK_WIDGET(label), FALSE); } gtk_widget_show(GTK_WIDGET(input_dbox)); cui_tray_disable(); } static void agent_popup_login_dbox(void) { GtkEntry *entry; set_entry(cui_builder, "login_username", "", ""); entry = set_entry(cui_builder, "login_password", "", ""); gtk_entry_set_visibility(entry, FALSE); gtk_widget_show(GTK_WIDGET(login_dbox)); cui_tray_disable(); } static void agent_input_cb(const char *path, gboolean hidden, gboolean identity, gboolean passphrase, const char *previous_passphrase, gboolean wpspin, const char *previous_wpspin, gboolean login) { if (g_strcmp0(path, service.path) != 0) { connman_agent_reply_canceled(); return; } if (passphrase == TRUE || hidden == TRUE) agent_popup_input_dbox(hidden, passphrase, previous_passphrase, wpspin, previous_wpspin); else if (login == TRUE) agent_popup_login_dbox(); else connman_agent_reply_canceled(); } static void agent_cancel_cb(void) { gtk_widget_hide(GTK_WIDGET(input_dbox)); cui_tray_enable(); } static void agent_ok_input(GtkButton *button, gpointer user_data) { const char *name, *passphrase, *wpspin; GtkToggleButton *toggle; gboolean wps = FALSE; GtkEntry *entry; name = passphrase = wpspin = NULL; entry = (GtkEntry *)gtk_builder_get_object(cui_builder, "hidden_entry"); if (gtk_entry_get_text_length(entry) > 0) name = gtk_entry_get_text(entry); entry = (GtkEntry *)gtk_builder_get_object(cui_builder, "secret_entry"); toggle = (GtkToggleButton *)gtk_builder_get_object(cui_builder, "passphrase_button"); if (gtk_toggle_button_get_active(toggle) == TRUE) passphrase = gtk_entry_get_text(entry); toggle = (GtkToggleButton *)gtk_builder_get_object(cui_builder, "wpspbc_button"); if (gtk_toggle_button_get_active(toggle) == TRUE) { wps = TRUE; wpspin = ""; } toggle = (GtkToggleButton *)gtk_builder_get_object(cui_builder, "wpspin_button"); if (gtk_toggle_button_get_active(toggle) == TRUE) { wps = TRUE; wpspin = gtk_entry_get_text(entry); } connman_agent_reply_passphrase(name, passphrase, wps, wpspin); gtk_widget_hide(GTK_WIDGET(input_dbox)); cui_tray_enable(); } static void agent_ok_login(GtkButton *button, gpointer user_data) { GtkEntry *entry; const char *username, *password; username = password = NULL; entry = (GtkEntry *)gtk_builder_get_object(cui_builder, "login_username"); if (gtk_entry_get_text_length(entry) > 0) username = gtk_entry_get_text(entry); entry = (GtkEntry *)gtk_builder_get_object(cui_builder, "login_password"); if (gtk_entry_get_text_length(entry) > 0) password = gtk_entry_get_text(entry); connman_agent_reply_login(username, password); gtk_widget_hide(GTK_WIDGET(login_dbox)); cui_tray_enable(); } static void cancel(void) { cui_tray_enable(); connman_agent_reply_canceled(); } static void agent_cancel(GtkButton *button, gpointer user_data) { GtkDialog *dialog_box = user_data; gtk_widget_hide(GTK_WIDGET(dialog_box)); cancel(); } static void agent_close(GtkDialog *dialog_box, gint response_id, gpointer user_data) { if (response_id == GTK_RESPONSE_DELETE_EVENT || response_id == GTK_RESPONSE_CLOSE) cancel(); } static void agent_retry(GtkButton *button, gpointer user_data) { gtk_widget_hide(GTK_WIDGET(error_dbox)); cui_tray_enable(); connman_agent_reply_retry(); } static void agent_passphrase_changed(GtkToggleButton *togglebutton, gpointer user_data) { const gchar *label; GtkWidget *entry; entry = (GtkWidget *)gtk_builder_get_object(cui_builder, "secret_entry"); label = gtk_button_get_label(GTK_BUTTON(togglebutton)); if (g_strcmp0(label, "WPS Push-Button") == 0) { gtk_widget_set_sensitive(entry, FALSE); set_widget_sensitive(cui_builder, "input_ok", TRUE); } else gtk_widget_set_sensitive(entry, TRUE); } void cui_agent_init_callbacks(void) { connman_agent_set_error_cb(agent_error_cb); connman_agent_set_browser_cb(agent_browser_cb); connman_agent_set_input_cb(agent_input_cb); connman_agent_set_cancel_cb(agent_cancel_cb); } static gboolean change_invisible_char_on_entry(GtkWidget *widget, GdkEvent *event, gpointer user_data) { GdkEventCrossing *ev_cross = (GdkEventCrossing *) event; GtkEntry *entry = user_data; if (ev_cross->type == GDK_ENTER_NOTIFY) gtk_entry_set_visibility(entry, TRUE); else gtk_entry_set_visibility(entry, FALSE); return TRUE; } void cui_agent_set_selected_service(const char *path, const char *name) { g_free(service.path); service.path = g_strdup(path); g_free(service.name); if (name == NULL) service.name = g_strdup("Hidden"); else service.name = g_strdup(name); } static void agent_ok_tethering(GtkButton *button, gpointer user_data) { GtkEntry *entry; entry = (GtkEntry *) gtk_builder_get_object(cui_builder, "tethering_ssid"); connman_technology_set_tethering_identifier(technology, gtk_entry_get_text(entry)); entry = (GtkEntry *) gtk_builder_get_object(cui_builder, "tethering_passphrase"); connman_technology_set_tethering_passphrase(technology, gtk_entry_get_text(entry)); if (tethering == TRUE) connman_technology_tether(technology, TRUE); g_free(technology); technology = NULL; tethering = FALSE; gtk_widget_hide(GTK_WIDGET(tethering_dbox)); cui_tray_enable(); } static void agent_popup_tethering_dbox(void) { const char *value; GtkEntry *entry; value = connman_technology_get_tethering_identifier(technology); set_entry(cui_builder, "tethering_ssid", value, ""); value = connman_technology_get_tethering_passphrase(technology); entry = set_entry(cui_builder, "tethering_passphrase", value, ""); gtk_entry_set_visibility(entry, FALSE); if (gtk_entry_get_text_length(entry) >= 8) set_widget_sensitive(cui_builder, "tethering_ok", TRUE); else set_widget_sensitive(cui_builder, "tethering_ok", FALSE); gtk_widget_show(GTK_WIDGET(tethering_dbox)); cui_tray_disable(); } static gboolean secret_entry_key_release_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data) { GtkEntry *entry = GTK_ENTRY(widget); GtkWidget *button = user_data; gboolean enable = FALSE; if (gtk_entry_get_text_length(entry) >= 8) enable = TRUE; gtk_widget_set_sensitive(button, enable); return TRUE; } void cui_agent_set_wifi_tethering_settings(const char *path, gboolean tether) { const char *ssid, *passphrase; g_free(technology); technology = g_strdup(path); if (technology == NULL) return; tethering = tether; ssid = connman_technology_get_tethering_identifier(path); passphrase = connman_technology_get_tethering_passphrase(path); if (tethering == TRUE && (ssid == NULL || passphrase == NULL)) agent_popup_tethering_dbox(); else if (tethering == TRUE) connman_technology_tether(path, TRUE); else agent_popup_tethering_dbox(); } gint cui_load_agent_dialogs(void) { GError *error = NULL; GtkWidget *button, *entry; memset(&service, 0, sizeof(struct cui_selected_service)); gtk_builder_add_from_file(cui_builder, CUI_AGENT_DIALOG_UI_PATH, &error); if (error != NULL) { printf("Error: %s\n", error->message); g_error_free(error); return -EINVAL; } input_dbox = (GtkDialog *) gtk_builder_get_object(cui_builder, "input_dbox"); login_dbox = (GtkDialog *) gtk_builder_get_object(cui_builder, "login_dbox"); error_dbox = (GtkDialog *) gtk_builder_get_object(cui_builder, "error_dbox"); tethering_dbox = (GtkDialog *) gtk_builder_get_object(cui_builder, "tethering_dbox"); /* Passphrase dbox buttons */ button = (GtkWidget *) gtk_builder_get_object(cui_builder, "input_ok"); g_signal_connect(button, "clicked", G_CALLBACK(agent_ok_input), NULL); entry = (GtkWidget *) gtk_builder_get_object(cui_builder, "secret_entry"); g_signal_connect(entry, "enter-notify-event", G_CALLBACK(change_invisible_char_on_entry), entry); g_signal_connect(entry, "leave-notify-event", G_CALLBACK(change_invisible_char_on_entry), entry); g_signal_connect(entry, "key-release-event", G_CALLBACK(secret_entry_key_release_cb), button); button = (GtkWidget *) gtk_builder_get_object(cui_builder, "passphrase_button"); g_signal_connect(button, "toggled", G_CALLBACK(agent_passphrase_changed), NULL); button = (GtkWidget *) gtk_builder_get_object(cui_builder, "wpspbc_button"); g_signal_connect(button, "toggled", G_CALLBACK(agent_passphrase_changed), NULL); button = (GtkWidget *) gtk_builder_get_object(cui_builder, "wpspin_button"); g_signal_connect(button, "toggled", G_CALLBACK(agent_passphrase_changed), NULL); button = (GtkWidget *) gtk_builder_get_object(cui_builder, "input_cancel"); g_signal_connect(button, "clicked", G_CALLBACK(agent_cancel), input_dbox); g_signal_connect(input_dbox, "response", G_CALLBACK(agent_close), NULL); g_signal_connect(input_dbox, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); /* Login dbox widgets */ button = (GtkWidget *) gtk_builder_get_object(cui_builder, "login_ok"); g_signal_connect(button, "clicked", G_CALLBACK(agent_ok_login), NULL); entry = (GtkWidget *) gtk_builder_get_object(cui_builder, "login_password"); g_signal_connect(entry, "enter-notify-event", G_CALLBACK(change_invisible_char_on_entry), entry); g_signal_connect(entry, "leave-notify-event", G_CALLBACK(change_invisible_char_on_entry), entry); button = (GtkWidget *) gtk_builder_get_object(cui_builder, "login_cancel"); g_signal_connect(button, "clicked", G_CALLBACK(agent_cancel), login_dbox); g_signal_connect(login_dbox, "response", G_CALLBACK(agent_close), NULL); g_signal_connect(login_dbox, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); /* Tethering dbox widgets */ button = (GtkWidget *) gtk_builder_get_object(cui_builder, "tethering_ok"); g_signal_connect(button, "clicked", G_CALLBACK(agent_ok_tethering), NULL); entry = (GtkWidget *) gtk_builder_get_object(cui_builder, "tethering_passphrase"); g_signal_connect(entry, "enter-notify-event", G_CALLBACK(change_invisible_char_on_entry), entry); g_signal_connect(entry, "leave-notify-event", G_CALLBACK(change_invisible_char_on_entry), entry); g_signal_connect(entry, "key-release-event", G_CALLBACK(secret_entry_key_release_cb), button); button = (GtkWidget *) gtk_builder_get_object(cui_builder, "tethering_cancel"); g_signal_connect(button, "clicked", G_CALLBACK(agent_cancel), tethering_dbox); g_signal_connect(tethering_dbox, "response", G_CALLBACK(agent_close), NULL); g_signal_connect(tethering_dbox, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); /* Error dbox buttons */ button = (GtkWidget *) gtk_builder_get_object(cui_builder, "error_retry"); g_signal_connect(button, "clicked", G_CALLBACK(agent_retry), NULL); button = (GtkWidget *) gtk_builder_get_object(cui_builder, "error_cancel"); g_signal_connect(button, "clicked", G_CALLBACK(agent_cancel), error_dbox); g_signal_connect(error_dbox, "response", G_CALLBACK(agent_close), NULL); g_signal_connect(error_dbox, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); return 0; } connman-ui-0_20150622+dfsg.orig/src/gtktechnology.h0000644000175000017500000000400212541725135020372 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef __GTK_TECHNOLOGY_H__ #define __GTK_TECHNOLOGY_H__ #include #include G_BEGIN_DECLS #define GTK_TYPE_TECHNOLOGY \ (gtk_technology_get_type()) #define GTK_TECHNOLOGY(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj), \ GTK_TYPE_TECHNOLOGY, GtkTechnology)) #define GTK_TECHNOLOGY_CLASS(klass) \ (G_TYPE_CHECK_CLASS_CAST((klass), \ GTK_TYPE_TECHNOLOGY, GtkTechnologyClass)) #define GTK_IS_TECHNOLOGY(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_TECHNOLOGY)) #define GTK_IS_TECHNOLOGY_CLASS(klass) \ (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_TECHNOLOGY)) #define GTK_TECHNOLOGY_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS((obj), \ GTK_TYPE_TECHNOLOGY, GtkTechnologyClass)) typedef struct _GtkTechnology GtkTechnology; typedef struct _GtkTechnologyClass GtkTechnologyClass; typedef struct _GtkTechnologyPrivate GtkTechnologyPrivate; struct _GtkTechnology { GtkMenuItem parent_class; GtkTechnologyPrivate *priv; gchar *path; }; struct _GtkTechnologyClass { GtkMenuItemClass parent_class; }; GType gtk_technology_get_type(void) G_GNUC_CONST; GtkTechnology *gtk_technology_new(const gchar *path); GtkMenuItem *gtk_technology_get_tethering_item(GtkTechnology *technology); G_END_DECLS #endif /* __GTK_TECHNOLOGY_H__ */ connman-ui-0_20150622+dfsg.orig/src/tray.c0000644000175000017500000000554612541725135016501 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #define CUI_TRAYICON_UI_PATH CUI_UI_PATH "/tray.ui" static GtkStatusIcon *cui_trayicon = NULL; static void (*popup_left_menu_f)(GtkStatusIcon *, gpointer); static void (*popup_rigt_menu_f)(GtkStatusIcon *, guint, guint, gpointer); static int left_menu_handler_id = 0; static int right_menu_handler_id = 0; void cui_trayicon_update_icon(void) { enum connman_state state; GdkPixbuf *image = NULL; const char *info = NULL; state = connman_manager_get_state(); cui_theme_get_state_icone_and_info(state, &image, &info); gtk_status_icon_set_from_pixbuf(cui_trayicon, image); gtk_status_icon_set_tooltip_text(cui_trayicon, info); gtk_status_icon_set_visible(cui_trayicon, TRUE); } void cui_tray_hook_left_menu(gpointer callback) { popup_left_menu_f = callback; } void cui_tray_hook_right_menu(gpointer callback) { popup_rigt_menu_f = callback; } void cui_tray_left_menu_disable(void) { if (left_menu_handler_id != 0) { g_signal_handler_disconnect(cui_trayicon, left_menu_handler_id); left_menu_handler_id = 0; } } void cui_tray_enable(void) { if (left_menu_handler_id == 0) left_menu_handler_id = g_signal_connect(cui_trayicon, "activate", G_CALLBACK(popup_left_menu_f), NULL); if (right_menu_handler_id == 0) right_menu_handler_id = g_signal_connect(cui_trayicon, "popup-menu", G_CALLBACK(popup_rigt_menu_f), NULL); } void cui_tray_disable(void) { if (left_menu_handler_id != 0) g_signal_handler_disconnect(cui_trayicon, left_menu_handler_id); if (right_menu_handler_id != 0) g_signal_handler_disconnect(cui_trayicon, right_menu_handler_id); left_menu_handler_id = 0; right_menu_handler_id = 0; } gint cui_load_trayicon(GtkBuilder *builder) { GError *error = NULL; gtk_builder_add_from_file(builder, CUI_TRAYICON_UI_PATH, &error); if (error != NULL) { printf("Error: %s\n", error->message); g_error_free(error); return -EINVAL; } cui_trayicon = (GtkStatusIcon *) gtk_builder_get_object(builder, "cui_trayicon"); cui_trayicon_update_icon(); cui_load_left_menu(builder, cui_trayicon); cui_load_right_menu(builder, cui_trayicon); return 0; } connman-ui-0_20150622+dfsg.orig/src/left-menu.c0000644000175000017500000001675112541725135017416 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #define CUI_LEFT_MENU_UI_PATH CUI_UI_PATH "/left_menu.ui" static GtkMenu *cui_left_menu = NULL; static GtkMenu *cui_more_menu = NULL; static GtkMenuItem *cui_list_more_item = NULL; static GHashTable *service_items = NULL; static GtkMenuItem *cui_scan_spinner = NULL; static void add_or_update_service(const char *path, int position) { GtkService *s; s = gtk_service_new(path); if (position > 9) gtk_menu_shell_append(GTK_MENU_SHELL(cui_more_menu), (GtkWidget *)s); else gtk_menu_shell_insert(GTK_MENU_SHELL(cui_left_menu), (GtkWidget *)s, position); gtk_widget_set_visible((GtkWidget *)s, TRUE); gtk_widget_show((GtkWidget *)s); g_hash_table_insert(service_items, s->path, s); } static void remove_service_cb(const char *path) { g_hash_table_remove(service_items, path); /* Reposition left menu after updating the list */ gtk_menu_reposition(cui_left_menu); } static void accumulate_menu_size(GtkWidget* widget, gpointer data) { GtkRequisition *menu_size = (GtkRequisition *)data; GtkRequisition item_size; gtk_widget_get_preferred_size(widget, NULL, &item_size); menu_size->width = MAX(item_size.width, menu_size->width); menu_size->height += item_size.height; } static void menu_position_func(GtkMenu *menu, gint *out_x, gint *out_y, gboolean *push_in, gpointer user_data) { /* Placement logic comes from GTK+'s gtk_menu_position() in gtkmenu.c */ GtkWidget *widget = GTK_WIDGET(menu); GtkStatusIcon *trayicon = GTK_STATUS_ICON(user_data); GtkRequisition requisition; gint x, y; gint space_left, space_right, space_above, space_below; gint needed_width, needed_height, monitor_num; GdkScreen *screen; GdkRectangle area, monitor; GtkBorder padding, margin; GtkStyleContext *context; GtkStateFlags state; gboolean rtl = (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL); /* Always offset from tray icon */ if (gtk_status_icon_get_geometry(trayicon, NULL, &area, NULL)) { x = area.x + area.width / 2; y = area.y + area.height / 2; } else { x = 0; y = 0; } /* Resize menu */ requisition.width = 0; requisition.height = 0; gtk_container_foreach(GTK_CONTAINER(cui_left_menu), accumulate_menu_size, &requisition); gtk_widget_set_size_request(GTK_WIDGET(cui_left_menu), requisition.width, requisition.height); /* Start actual layout */ context = gtk_widget_get_style_context(widget); state = gtk_widget_get_state_flags(widget); gtk_style_context_get_padding(context, state, &padding); gtk_style_context_get_margin(context, state, &margin); screen = gtk_widget_get_screen(widget); monitor_num = gdk_screen_get_monitor_at_point(screen, x, y); gdk_screen_get_monitor_workarea(screen, monitor_num, &monitor); space_left = x - monitor.x; space_right = monitor.x + monitor.width - x - 1; space_above = y - monitor.y; space_below = monitor.y + monitor.height - y - 1; /* Position horizontally. */ needed_width = requisition.width - padding.left; if (needed_width <= space_left || needed_width <= space_right) { if ((rtl && needed_width <= space_left) || (!rtl && needed_width > space_right)) x = x - margin.left + padding.left - requisition.width + 1; else x = x + margin.right - padding.right; } else if (requisition.width <= monitor.width) { if (space_left > space_right) x = monitor.x; else x = monitor.x + monitor.width - requisition.width; } else { if (rtl) x = monitor.x + monitor.width - requisition.width; else x = monitor.x; } /* Position vertically */ needed_height = requisition.height - padding.top; if (needed_height <= space_above || needed_height <= space_below) { if (needed_height <= space_below) y = y + margin.top - padding.top; else y = y - margin.bottom + padding.bottom - requisition.height + 1; y = CLAMP(y, monitor.y, monitor.y + monitor.height - requisition.height); } else if (needed_height > space_below && needed_height > space_above) { if (space_below >= space_above) y = monitor.y + monitor.height - requisition.height; else y = monitor.y; } else { y = monitor.y; } *out_x = x; *out_y = y; } static void get_services_cb(void *user_data) { GSList *services, *list; int item_position = 2; services = connman_service_get_services(); if (services == NULL) return; gtk_widget_hide(GTK_WIDGET(cui_list_more_item)); for (list = services; list; list = list->next, item_position++) add_or_update_service(list->data, item_position); if (item_position > 10) gtk_widget_show(GTK_WIDGET(cui_list_more_item)); g_slist_free(services); /* Reposition left menu after updating the list */ gtk_menu_reposition(cui_left_menu); } static void scanning_cb(void *user_data) { GtkSpinner *spin; spin = (GtkSpinner *)gtk_bin_get_child(GTK_BIN(cui_scan_spinner)); gtk_spinner_stop(spin); gtk_widget_hide((GtkWidget *)cui_scan_spinner); gtk_widget_hide((GtkWidget *)spin); /* Reposition left menu after hidding the spinner */ gtk_menu_reposition(cui_left_menu); } static void delete_service_item(gpointer data) { GtkWidget *item = data; gtk_widget_destroy(item); } static void cui_popup_left_menu(GtkStatusIcon *trayicon, gpointer user_data) { GtkSpinner *spin; spin = (GtkSpinner *)gtk_bin_get_child(GTK_BIN(cui_scan_spinner)); gtk_widget_hide(GTK_WIDGET(cui_list_more_item)); gtk_widget_show((GtkWidget *)cui_scan_spinner); gtk_widget_show((GtkWidget *)spin); gtk_spinner_start(spin); connman_service_set_removed_callback(remove_service_cb); connman_service_refresh_services_list(get_services_cb, scanning_cb, user_data); gtk_menu_popup(cui_left_menu, NULL, NULL, menu_position_func, trayicon, 1, 0); } static void cui_popdown_left_menu(GtkMenu *menu, gpointer user_data) { connman_service_set_removed_callback(NULL); g_hash_table_remove_all(service_items); connman_service_free_services_list(); } gint cui_load_left_menu(GtkBuilder *builder, GtkStatusIcon *trayicon) { GError *error = NULL; gtk_builder_add_from_file(builder, CUI_LEFT_MENU_UI_PATH, &error); if (error != NULL) { printf("Error: %s\n", error->message); g_error_free(error); return -EINVAL; } cui_left_menu = (GtkMenu *) gtk_builder_get_object(builder, "cui_left_menu"); cui_more_menu = (GtkMenu *) gtk_builder_get_object(builder, "cui_more_menu"); cui_list_more_item = (GtkMenuItem *) gtk_builder_get_object(builder, "cui_list_more_item"); cui_scan_spinner = (GtkMenuItem *) gtk_builder_get_object(builder, "cui_scan_spinner"); gtk_container_add(GTK_CONTAINER(cui_scan_spinner), gtk_spinner_new()); g_signal_connect(cui_left_menu, "deactivate", G_CALLBACK(cui_popdown_left_menu), NULL); service_items = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, delete_service_item); cui_tray_hook_left_menu(cui_popup_left_menu); return 0; } connman-ui-0_20150622+dfsg.orig/src/gtkservice.h0000644000175000017500000000353312541725135017667 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef __GTK_SERVICE_H__ #define __GTK_SERVICE_H__ #include #include G_BEGIN_DECLS #define GTK_TYPE_SERVICE \ (gtk_service_get_type()) #define GTK_SERVICE(obj) \ (G_TYPE_CHECK_INSTANCE_CAST((obj), \ GTK_TYPE_SERVICE, GtkService)) #define GTK_SERVICE_CLASS(klass) \ (G_TYPE_CHECK_CLASS_CAST((klass), \ GTK_TYPE_SERVICE, GtkServiceClass)) #define GTK_IS_SERVICE(obj) \ (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_SERVICE)) #define GTK_IS_SERVICE_CLASS(klass) \ (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_SERVICE)) #define GTK_SERVICE_GET_CLASS(obj) \ (G_TYPE_INSTANCE_GET_CLASS((obj), \ GTK_TYPE_SERVICE, GtkServiceClass)) typedef struct _GtkService GtkService; typedef struct _GtkServiceClass GtkServiceClass; typedef struct _GtkServicePrivate GtkServicePrivate; struct _GtkService { GtkMenuItem parent_class; GtkServicePrivate *priv; gchar *path; }; struct _GtkServiceClass { GtkMenuItemClass parent_class; }; GType gtk_service_get_type(void) G_GNUC_CONST; GtkService *gtk_service_new(const gchar *path); G_END_DECLS #endif /* __GTK_SERVICE_H__ */ connman-ui-0_20150622+dfsg.orig/Makefile.am0000644000175000017500000000376112541725135016620 0ustar nicknickSUBDIRS = po AM_MAKEFLAGS = --no-print-directory includedir = @includedir@ include_HEADERS = noinst_HEADERS = local_headers = $(foreach file,$(include_HEADERS) $(nodist_include_HEADERS) \ $(noinst_HEADERS), include/$(notdir $(file))) gdbus_sources = gdbus/gdbus.h gdbus/mainloop.c gdbus/watch.c \ gdbus/object.c gdbus/polkit.c common_sources = lib/connman-interface.h lib/interface.c \ lib/dbus.c lib/manager.c lib/technology.c \ lib/service.c lib/agent.c if MAINTAINER_MODE uidir = $(abs_top_srcdir)/data/ui iconsdir = $(abs_top_srcdir)/data/icons localdir = $(abs_top_srcdir)/po else uidir = $(datadir)/connman_ui_gtk/ui iconsdir = $(datadir)/connman_ui_gtk/icons endif ui_DATA = data/ui/agent.ui data/ui/left_menu.ui data/ui/right_menu.ui \ data/ui/settings.ui data/ui/tray.ui icons_DATA = data/icons/gsm-3g-full.png \ data/icons/network-wired-symbolic.png \ data/icons/network-wireless-signal-excellent-symbolic.png \ data/icons/network-wireless-signal-good-symbolic.png \ data/icons/network-wireless-signal-weak-symbolic.png \ data/icons/network-wireless-signal-ok-symbolic.png \ data/icons/network-offline-symbolic.png \ data/icons/network-transmit-receive-symbolic.png \ data/icons/network-idle-symbolic.png \ data/icons/nm-adhoc.png AM_CFLAGS = @GLIB_CFLAGS@ @DBUS_CFLAGS@ \ -DCUI_UI_PATH=\""$(uidir)"\" \ -DCUI_ICON_PATH=\"$(iconsdir)\" \ -DLOCALEDIR=\"$(localedir)\" bin_PROGRAMS = src/connman-ui-gtk src_connman_ui_gtk_SOURCES = $(gdbus_sources) $(common_sources) \ src/main.c src/tray.c \ src/left-menu.c src/right-menu.c \ src/gtktechnology.h src/gtktechnology.c \ src/gtkservice.h src/gtkservice.c \ src/agent_dialogs.c src/settings.c \ src/theme.c src/utils.c src_connman_ui_gtk_CFLAGS = $(AM_CFLAGS) @GTK_CFLAGS@ src_connman_ui_gtk_LDADD = @GLIB_LIBS@ @DBUS_LIBS@ @GTK_LIBS@ AM_CPPFLAGS = -I$(builddir)/include -I$(builddir)/src \ -I$(srcdir)/gdbus -I$(srcdir)/lib ACLOCAL_AMFLAGS = -I m4 EXTRA_DIST = m4/ChangeLog $(ui_DATA) $(icons_DATA) connman-ui-0_20150622+dfsg.orig/data/0000755000175000017500000000000012541725135015466 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/data/icons/0000755000175000017500000000000012541725135016601 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/data/icons/network-wireless-signal-excellent-symbolic.png0000644000175000017500000000677012541725135027720 0ustar nicknick‰PNG  IHDRóÿa pHYs  šœ MiCCPPhotoshop ICC profilexÚSwX“÷>ß÷eVBØð±—l"#¬ÈY¢’a„@Å…ˆ VœHUÄ‚Õ Hˆâ (¸gAŠˆZ‹U\8îܧµ}zïííû×û¼çœçüÎyÏ€&‘æ¢j9R…<:ØOHÄɽ€Hà æËÂgÅðyx~t°?ü¯opÕ.$ÇáÿƒºP&W ‘à"ç RÈ.TÈÈ°S³d ”ly|B"ª ìôI>Ø©“ÜØ¢©™(G$@»`UR,À ¬@".À®€Y¶2G€½vŽX@`€™B,Ì 8CÍ L 0Ò¿à©_p…¸HÀË•Í—KÒ3¸•Ðwòðàâ!âÂl±Ba)f ä"œ—›#HçLÎ ùÑÁþ8?çæäáæfçlïôÅ¢þkðo">!ñßþ¼ŒNÏïÚ_ååÖpÇ°u¿k©[ÚVhßù]3Û  Z Ðzù‹y8ü@ž¡PÈ< í%b¡½0ã‹>ÿ3áoà‹~öü@þÛzðqš@™­À£ƒýqanv®RŽçËB1n÷ç#þÇ…ýŽ)Ñâ4±\,ŠñX‰¸P"MÇy¹R‘D!É•âé2ñ–ý “w ¬†OÀN¶µËlÀ~î‹XÒv@~ó-Œ ‘g42y÷“¿ù@+Í—¤ã¼è\¨”LÆD *°A Á¬ÀœÁ¼ÀaD@ $À<Bä€ ¡–ATÀ:ص° šá´Á18 çà\ëp`žÂ¼† AÈa!:ˆbŽØ"ΙŽ"aH4’€¤ éˆQ"ÅÈr¤©Bj‘]H#ò-r9\@úÛÈ 2ŠüŠ¼G1”²QÔu@¹¨ŠÆ sÑt4]€–¢kÑ´=€¶¢§ÑKèut}ŠŽc€Ñ1fŒÙa\Œ‡E`‰X&ÇcåX5V5cX7vÀžaï$‹€ì^„Âl‚GXLXC¨%ì#´ºW ƒ„1Â'"“¨O´%zùÄxb:±XF¬&î!!ž%^'_“H$É’äN !%2I IkHÛH-¤S¤>ÒiœL&ëmÉÞä²€¬ —‘·O’ûÉÃä·:ňâL ¢$R¤”J5e?奟2B™ ªQÍ©žÔªˆ:ŸZIm vP/S‡©4uš%Í›Cˤ-£ÕКigi÷h/étº ݃E—ЗÒkèéçéƒôw † ƒÇHb(k{§·/™L¦Ó—™ÈT0×2™g˜˜oUX*ö*|‘Ê•:•V•~•çªTUsU?Õyª T«U«^V}¦FU³Pã© Ô«Õ©U»©6®ÎRwRPÏQ_£¾_ý‚úc ²†…F †H£Tc·Æ!Æ2eñXBÖrVë,k˜Mb[²ùìLvûv/{LSCsªf¬f‘fæqÍƱàð9ÙœJÎ!Î Î{--?-±Öj­f­~­7ÚzÚ¾ÚbírííëÚïup@,õ:m:÷u º6ºQº…ºÛuÏê>Ócëyé õÊõéÝÑGõmô£õêïÖïÑ7046l18cðÌcèk˜i¸Ñð„á¨Ëhº‘Äh£ÑI£'¸&î‡gã5x>f¬ob¬4ÞeÜkVyVõV׬IÖ\ë,ëmÖWlPW› ›:›Ë¶¨­›­Äv›mßâ)Ò)õSnÚ1ìüì ìšìí9öaö%ömöÏÌÖ;t;|rtuÌvlp¼ë¤á4éĩÃéWgg¡só5¦KË—v—Sm§Š§nŸzË•åîºÒµÓõ£›»›Ü­ÙmÔÝÌ=Å}«ûM.›É]Ã=ïAôð÷XâqÌ㧛§Âóç/^v^Y^û½O³œ&žÖ0mÈÛÄ[à½Ë{`:>=eúÎé>Æ>ŸzŸ‡¾¦¾"ß=¾#~Ö~™~üžû;úËýø¿áyòñN`Áå½³k™¥5»/ >B Yr“oÀòùc3Üg,šÑÊZú0Ì&LÖŽ†Ïß~o¦ùLé̶ˆàGlˆ¸i™ù})*2ª.êQ´Stqt÷,Ö¬äYûg½Žñ©Œ¹;Ûj¶rvg¬jlRlc웸€¸ª¸x‡øEñ—t$ í‰äÄØÄ=‰ãsçlš3œäšT–tc®åÜ¢¹æéÎËžwç|þü/÷„óû%ÒŸ3gAMA±Ž|ûQ“ cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅFIDATxÚ\’Koe…Ÿï›_b“ØŽ“K“ÞI[E‚M[ZVbê"Tˆ-»þvCY±¬ vH‘hÝ Jˆ"!AR$) *Mä¦Iì\;öÌx<×ES’òHgyÎy¥÷qâ/ïÏ YJ0mv?™N&óÉ|I€T êÞ~µÖÙ_ŠzîßÿnZ-qˆ ï2&çz¼âç7.i3£™ÑÓåÌ°©I@+2öú„í ~ÿS¡¿ï±¸ëØ,Gq›+¥¾üÍó£§/N”ÊÅLFC%bÃ!Ö< Åid˜/å„Tv6¶—ª•‡{í»bè«¡í·Ç'Ÿ¶^ÅMnZ Ó_3S‰-SÏ{RÙQ+×öœ²o§Ndý‘d6¡cIæWÿz¡Ç"ú¥«ìÙ=¯ºê;s©Dô«aðÜ4r¼6jBWR“éNÜ)ú©î™]wõZ«ë]ÏòÆ°jIÈ;Œ‹ú•Þlò‘‘s¶ƒŽŽ& H»ŒåÊtCŽ ÂZ¾N»)|ÆÛMñq³=ú—î» ÈHÉÝòGÙþx¸5û‚8T–ì[um#,m=ðMeº híƒG‡æˆdO&õÙ['n\»|uêLñd¿aH¾«Âg»•ý}ºìÖæš[Y}z¨ y )%¼’¦ƒ4@K²—lü¦õÖq³+}KhÔ/ËKçÿ(Ð4쎬mù­!Ë·Ìv¼÷mo‘–¯ŸðïzgÀ¤ó“ÒIEND®B`‚connman-ui-0_20150622+dfsg.orig/data/icons/network-wireless-signal-good-symbolic.png0000644000175000017500000000677612541725135026673 0ustar nicknick‰PNG  IHDRóÿa pHYs  šœ MiCCPPhotoshop ICC profilexÚSwX“÷>ß÷eVBØð±—l"#¬ÈY¢’a„@Å…ˆ VœHUÄ‚Õ Hˆâ (¸gAŠˆZ‹U\8îܧµ}zïííû×û¼çœçüÎyÏ€&‘æ¢j9R…<:ØOHÄɽ€Hà æËÂgÅðyx~t°?ü¯opÕ.$ÇáÿƒºP&W ‘à"ç RÈ.TÈÈ°S³d ”ly|B"ª ìôI>Ø©“ÜØ¢©™(G$@»`UR,À ¬@".À®€Y¶2G€½vŽX@`€™B,Ì 8CÍ L 0Ò¿à©_p…¸HÀË•Í—KÒ3¸•Ðwòðàâ!âÂl±Ba)f ä"œ—›#HçLÎ ùÑÁþ8?çæäáæfçlïôÅ¢þkðo">!ñßþ¼ŒNÏïÚ_ååÖpÇ°u¿k©[ÚVhßù]3Û  Z Ðzù‹y8ü@ž¡PÈ< í%b¡½0ã‹>ÿ3áoà‹~öü@þÛzðqš@™­À£ƒýqanv®RŽçËB1n÷ç#þÇ…ýŽ)Ñâ4±\,ŠñX‰¸P"MÇy¹R‘D!É•âé2ñ–ý “w ¬†OÀN¶µËlÀ~î‹XÒv@~ó-Œ ‘g42y÷“¿ù@+Í—¤ã¼è\¨”LÆD *°A Á¬ÀœÁ¼ÀaD@ $À<Bä€ ¡–ATÀ:ص° šá´Á18 çà\ëp`žÂ¼† AÈa!:ˆbŽØ"ΙŽ"aH4’€¤ éˆQ"ÅÈr¤©Bj‘]H#ò-r9\@úÛÈ 2ŠüŠ¼G1”²QÔu@¹¨ŠÆ sÑt4]€–¢kÑ´=€¶¢§ÑKèut}ŠŽc€Ñ1fŒÙa\Œ‡E`‰X&ÇcåX5V5cX7vÀžaï$‹€ì^„Âl‚GXLXC¨%ì#´ºW ƒ„1Â'"“¨O´%zùÄxb:±XF¬&î!!ž%^'_“H$É’äN !%2I IkHÛH-¤S¤>ÒiœL&ëmÉÞä²€¬ —‘·O’ûÉÃä·:ňâL ¢$R¤”J5e?奟2B™ ªQÍ©žÔªˆ:ŸZIm vP/S‡©4uš%Í›Cˤ-£ÕКigi÷h/étº ݃E—ЗÒkèéçéƒôw † ƒÇHb(k{§·/™L¦Ó—™ÈT0×2™g˜˜oUX*ö*|‘Ê•:•V•~•çªTUsU?Õyª T«U«^V}¦FU³Pã© Ô«Õ©U»©6®ÎRwRPÏQ_£¾_ý‚úc ²†…F †H£Tc·Æ!Æ2eñXBÖrVë,k˜Mb[²ùìLvûv/{LSCsªf¬f‘fæqÍƱàð9ÙœJÎ!Î Î{--?-±Öj­f­~­7ÚzÚ¾ÚbírííëÚïup@,õ:m:÷u º6ºQº…ºÛuÏê>Ócëyé õÊõéÝÑGõmô£õêïÖïÑ7046l18cðÌcèk˜i¸Ñð„á¨Ëhº‘Äh£ÑI£'¸&î‡gã5x>f¬ob¬4ÞeÜkVyVõV׬IÖ\ë,ëmÖWlPW› ›:›Ë¶¨­›­Äv›mßâ)Ò)õSnÚ1ìüì ìšìí9öaö%ömöÏÌÖ;t;|rtuÌvlp¼ë¤á4éĩÃéWgg¡só5¦KË—v—Sm§Š§nŸzË•åîºÒµÓõ£›»›Ü­ÙmÔÝÌ=Å}«ûM.›É]Ã=ïAôð÷XâqÌ㧛§Âóç/^v^Y^û½O³œ&žÖ0mÈÛÄ[à½Ë{`:>=eúÎé>Æ>ŸzŸ‡¾¦¾"ß=¾#~Ö~™~üžû;úËýø¿áyòñN`Áå½³k™¥5»/ >B Yr“oÀòùc3Üg,šÑÊZú0Ì&LÖŽ†Ïß~o¦ùLé̶ˆàGlˆ¸i™ù})*2ª.êQ´Stqt÷,Ö¬äYûg½Žñ©Œ¹;Ûj¶rvg¬jlRlc웸€¸ª¸x‡øEñ—t$ í‰äÄØÄ=‰ãsçlš3œäšT–tc®åÜ¢¹æéÎËžwç|þü/÷„óû%ÒŸ3gAMA±Ž|ûQ“ cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅFIDATxÚd’Ëk\e‡Ÿï›sfÎLæLšLn%é%¨EÚFK®ªÕE Ðº±Aué¢þ ¢5©®#¤®ºðFÁ H Bb#Í…¤m2“Ä$3“¹œ9÷ïsÑ„úÛ½/¼¿÷y/Bk ÀÌÌŒ.T*•‘l6{6™LvI)„RJ{žWpg>ŸÏ7444ϾŒññq”Rç‹ÅâûÃÃù\îél6k !ÐZÓh4úÃ0ìžššj›žž–¤”ˆ±±±—-˺nÛöEÛ¶;,ËÂ0 „H!Þ7‰ÂÏó¨V«[µZíŽïû£bbbb«½½½[)EGH)ë™TæQʲ6 ÃðÑZÇJå<ß;îùî)4©²r¹üÐPJÝõ$ò¢¥³å–™2M&R«i3S6L#¡ã(JËXt¤Uú™r£t¹6_7Sf¯RjÞp=÷#|~ØNlÿÔjµmýÒüž¥æ_$E_® 7òqÜ l új#æ«ÛîÎQçç{Õ½kÀ1qs‚oOw>Ó.™v¬ävÏk-mqoÞ¶q¤ëõ Ô(ë^Wá¶ï ßÈðjæ*Æ‚¿Àèî(žrS™´õö@ç©7ß½üÎ󙌴MSJ®ŽšMUûòÏ›o-6×oM–¿½ý·3§®ä® Ä Áþ/œ<9poðL¿skd[5=©“4ã:EçQµdý4³«+þla3 —º²nL¼pDØÅß»Íó d^|X 7eÁ_<³ÞÅtü »någ4E$(­08”WJ×—«¥¯NäŽZ=¨6Nâ8 /v»–Ëÿ\ú·Á ç HpãÐÁÎÃñú‚µ%ƒs}§ ¢˜Åâ½OÅh4[ˆ=¨àÖaã4ÊZ$-q±¼)®Æ±ÔB2YXÖ³iTxX ÄLJV€ý/<{vúÃKïuF‘â“»ßlÌ=¸ÿ°‚äˆ ùÿ„­A$ØIu—+¥f¯U(aÛ›'Á.êHó'GxŒ‰ Wî~Q ª=õ n×ÔÎ×­T¥à ‡ÿÛ’î!Av1IEND®B`‚connman-ui-0_20150622+dfsg.orig/data/icons/ICONS_LICENSE0000644000175000017500000000042612541725135020543 0ustar nicknick- bad_signal.png, low_signal.png, medium_signal.png, good_signal.png, network_online.png: LGPL © Everaldo Coelho (Crystal Clear icon set) - cellular.png, ethernet.png, network_connected.png, network_disconnected, tethering.png: GPL © Gnome Project (Gnome Web icon set) connman-ui-0_20150622+dfsg.orig/data/icons/network-wired-symbolic.png0000644000175000017500000000147412541725135023735 0ustar nicknick‰PNG  IHDRàw=øbKGD.46kjòÏ pHYs  šœtIMEÖ .†Áë‘tEXtCommentToolbar-sized icon ============ (c) 2004 Jakub 'jimmac' Steiner, http://jimmac.musichall.cz created with the GIMP, http://www.gimp.org…ŠÂ",IDATHǵ•ÏnQÆXXŠX,eQi ‹bŸ¤²Q(™•ø >@“¦‰.ª¤1¢qcd¬MÓôˆ]ˆ À’™iXõÃLl#êYÝ¿ç;ßwïw¯â±»·ó8f¶xÂ2K ÙÝۑȤ¥Ø¶…J‚  ÛÁ¾ˆpka€‰´vÓªa€h4êÏ;ççBmí&]\ôÇLÓôÁr¹.;u¹ob‘ËÊoß×þ’góÑ&hüµ¡iÈ…ˆŒ$x÷¡F6›%~;Žˆžž'‘°£hÐC†áp­e>­5ËÉ„+›Aû’øl§•HDP_¹›ày©Ìý{«OŸ‘\Nøç,fbz´ÂŠQ \.«ÊK¿j™ÀÛÔëõÈçóÄb±+×9¶ÍE@¢©Œ6¼åX¶…eY¾‰Ey†P 0‚OT,ÞU ¯¾xÍúƒu×LJðý¤”ëåºQ „dr…ÚÁþ• ªß¿™™p8ÌÙÙÝnÃ0Ø.oñ¥þuâg4‰\+Q¦^¯“J¥H§Ó†A§Ó v°?ÿs],FžÝv»-ÍfSŠ¥‚Ìò!\ëƒN§C¿ßǶmÇaÖUÇk·Z-÷Ú9Ÿ>ؘ`ü â^ãäô˜“Sÿ§Ü84~ßÀj°sh-}æˆP@ž5à×ÆO¶Ë[ž$s%j¿æÝžb© ÅRá!7ÿ59ð‰ihݤ[ˆIEND®B`‚connman-ui-0_20150622+dfsg.orig/data/icons/network-transmit-receive-symbolic.png0000644000175000017500000000241212541725135026075 0ustar nicknick‰PNG  IHDRÄ´l;ÑIDAT8…ÔmlSeÀñÿí½]i»ueÝ †( &0^ Æ .`ñ…4_?`bübC@b "QM4@g /cÈD`0pkY»n}Ûmïzïm×ûø Ý/çÛóäœ_NÎóäH<(j·*À\ ®¢´¸ÞéP&t÷%ŽZ–¸\ £Q¿_©ôtÁŠEU¿®o¨žX=­Ÿ×‰Ûe'ÕI¨GN\Ïî?röÕÜÅ>°¹QæËû¶ýÔrSô„Òb ž})M¤E2eŠhB‘XFDºð_‹—Þ;è§vkÑCÑ) »Þ¿Ñ ÕáHRnGDßÀ HeE>o 5mŠþXFÄ ‘ÒL¡erâÙ·¿i¾Û‘G*–ïœuà£5GôŒ)¥Õ(fN Éã•Ì\]7H¦ r9 Ã4q»¸ Õ•M?z}Ò­ûØÕ{ÂÏ­~Ó²cÇ1gî\°9È –€´f’1ò  ,aá(P(r;TÕXs>>óúO ÛˆÇRì’ŸÅb§u]7‚Áà¨|MÓÀ|èŒëëë§Úl¶Ò‘wB¡ëúÅÖÖVq¿º‡]B6G> IEND®B`‚connman-ui-0_20150622+dfsg.orig/data/icons/gsm-3g-full.png0000644000175000017500000001760612541725135021356 0ustar nicknick‰PNG  IHDR@@ªiqÞbKGDÿÿÿ ½§“tIMEØ " Ç“™(IDATxœí{k”]ÇUæ·«ê<ï«ûöS-©ÕîÖ[j«eÉ66 IìX~@â ƒYœ+ ²€3³ ™IhgÆ$°`˜Ex,'xLâ„$2“@Là ‰Bˆõ°ÞnI­G«ÕÏ{»oßç9§ªöüh)ãÈm¹eÃÌü`¯uÖ©{Ï9U{û«]U§öþMnZhpÅ®]{$ú­ Úµkü¿¥mÛ}ÀÙ¶û€ðÿÆ_¦M»ö¸ zÝ7uóêèµ¥µøç=¿ÖßœŽLƒONl|6l£+W2¯i»««Ì'6N󦓻xð·À7Õ3ÝõèøÓeÏ~ýW¢¥>¶dVïüCO.K¹uVíêäÁÁA±k—=D£Ñ”èÈÔ<ëQu¾@X¶ 4_oY0t|©l Ï6G ÇZû62><-” ‚§ë ×”ôWÍC# )¤Ž„ ˆ¼Ä ‹&a²ÂŠê¬(xÔÔÞ¿1?¸÷ºåÞ½{¹cË{á±ÈLýÊ¢Ž»&7dÀ¶ÝÏ„”bçèó×{¶¹¹·Síö‡6nŽ½|›òü¬’žQ–…ÕnÝjÏx…¢l£l]":AÚ‘*ëÅ•œ”6 ÉY)mÖ‹+9GªlèéºD®ÎQV(ÊaÝj/ª7\Ë‘žQžŸU=«zã6–6åövìÞýÌk†¿£Ï?^£;Ûv?³(K–æ¨a«ÀuÃ3íØýb^«tªgEGEëXANÊ°c œ$ŽÜÈpz¾bZL5ÊK­2ÒiYçŒQ"#tœ1äeJ²¤8“P’5ä-ü¯DFÖ9C.g’šl®Õã–89Ë"LâÈ5NÊ°c9­Û«ZäS­}ùÝ»(ð«ç&ÄÔ°U«UÓ›`ÛîgëtSÏÅÊu—h×£'#Ë]í«d©-ã‰Zl”òBÕHŒÒl|b™kqgÆ8Yøžç8œavÓB‰Œ°:+¥­²'M'm•ÍAiauV(‘! R™Ùj¶Ó:+”“ÒlüF²Ðž4®Xž÷æçs]肳û^Å„¦ž‹¶"µm!7€løYŠM|ÝpC»wPÑ-c­ÆµÞòL¾.=£”¶Ê¢êÚ(é™’î6L™T³'…á ˆRš’¬Ã”¶™"Cà [}õ9ÈXˆŒÃ”Ö”dA”J‡ž‚4™+Óq·ÕAFTýT m`Qu”¶ª{msM$Ú»\¾Ø–Z«Ý»|„½ƒƒšbˆŸ}=;Õë]ˆC›¡Hü@Ù18(»VµÈ¡ãg—§Ã\9l ¤)ÃI»žl¨z áúåÒì2fÓÔÖÔ4k›&%] é6\¡D’8ÂHgmìøSŸí4_IuõóÚWOk-\'š´%é2I6&Qq._­TmS“?©]—Z¤áÕãrB™¶°\+ê®Rλïjá]ƒü}Çy¢&<›PX:Ì$žül–œüÔµ¿víÙ#;'ÒrôâP¨jëïi3e8B[•xUt&0\O—Êž¦–Ì,,²ð†cÙº€uMy>U8ö—?•&nëhë0ëÖ’µ§OñÌá=ïu³]‡[Ù£8]Aƒ)v±5H²a˜LÍÎ÷äØ­j@Š*³Ð*êÍu•Ïžë*¬¬œ¯ôçïà¶={ø…G5F«Z,y˜i±©õ¢Üõë/ø±êᮃƒWÁ 'eäÕåXm¬M4V¸ÖŽª§W$^h‡såh9‘Må›ü,§¬c=fåŒcãFX8ðü/ß¹íÖŽŸÿwŸ€ïÒXƒ8Ž u‚á3CøÏþù­ÅÏw6oÿ¹OI7S&‡YºìØ(åú‘3_ ¥êŠ¶¶ì¨11ÀlŠ9Hœˆ¬àÑùË­-õžFäµ3°ŠÁlyê©ú‹WúÔ]¿þ‚ÿÏÀk&r‹ÎºÖÞ“ŽŸùüïÿê ÒåEZ fgºTºE€°¼»m62‘ ­S–e¨È¤¦gf×y¡oR)ßXBŸß’ JÇÿúÇÖõ´¯ûÿþ? ÇqADB¢^¯¢Þ¨£µµÛnßNû¾÷Oa}n"ë·¯¾Ì‚ˆˆˆI(ŽØ‹âFSÊ÷ ’,iK #!kJåZÖ ø--Á´h0šæ|ÿߟãÁÁ÷›·ýD— õ±#û ‚‰jñP,,0^Î×eäå¤V‰LŒmâ8± Vz¤'ë[?ŽmW.LÅ åƒ)`kCÁ"0åée™‘;ž|r÷kÚK…!P¯×ÿÙÇE}úÌ€nÌ®„¥Œ`°µ!˜‚0’¸‘tÁXx±>éÁJÀ:nDy-|©U"#/'_Î×åàà ˆ‘$I¶Å[ÌÖEð܆‹øÚÄï±²h¤4e!¬+t,²¾pŒ±ã²ïyuö]H?ª'9c9G Ë:€µŽÏ‚ýò•£Íùä2¯ ÆDG9R"N"¬ê^…t&‹êåAȱ`_ LJµpH&Vd¢šn"ß…ô½:û.û^@³YS×RXWHS+‹F÷¡-{ºá.€FÃuH*¾æ}ÕÖ+´Jd µ”’R¡£ eâ&y‘ã¸1)7Ñ:G  ”PDž‚ðÚ‡µ9®Ïuôõõ"Ö1´þÁŤµ$ˆF/¬mºº:ÉÔ‹mD”…µ9‚ö„¸RZËiòbRnä8nçøB¡—ve µÔ*‘ª­wA%¨nÄ¢,U`i%öb«nea…+jDÂÚØ‹(8®£lÃÁeŽ=!¤kNAk ÏyÌÂ#¢IG@kñ¹1ä²ÍpÌ c ŒÑ°Ö‚Á°Ö€ GBpŠ­Œ™9&b†±Z‡Ðð‰àJŽ5‘H`žQÒ%‚K&5ëÁ,„-‹õºI|WMKeì¢KãE ë²MܵË"ÙZ2ã‰@j)|%„PÂZ“RÜð ÇZëÒ‘R°Rõ8Ê°.„pX°Á“n¯ SG°lQšŸEi~ÕZ¨Ž8Ž$1ØZcpitn¶#"(‚ƒ…z„Ó°œÖà”ô‰†VéXkÝDÃ!+SL–)|%©¥ÌxB¶–[×U±»t¬€±d=/šÅ$%ÈÔE¢²Z)@H¶9cå8R)á(f8žï[6ì&Úd[€+,yV³.(6 Ÿ†ë¸ˆ“¨Žz£Žz£†FÔ@’Ä !04<„8N.¿µ ¶®Õì K×4â,[v=©Âq˜á(á(Ç‘J›zV¡©®Eh¥HT–ÈÔE1I AƳ–€†h©2J7‰TUQÕ¸‚üHD^"<‰šŽl+‰D'ÊZ£¤€"éúÞüü\ÔÅPŠ \€])„#½•Û'Ÿ{î3ùÇ€“åÌê·—ˆ! L,­eE ²T*¯LçR3‰±Žp””/èacÝx~1b)ÈH¡cAž#¨ZÅ°i7•»~Qàu‚àΖ}•¯]^ƒË“3M}®¤ÒYŠ¢ºÐ–¨½9?;;×R‰´ÂÂjiØʶ¶ôøt±tg¡XYÖšOW ˆÀ õéL¾{£È_üâ¼ðÂÿDkk˜… Œ1X³åTØ'ÔgS[ª-ÌBQq¦Ô™$6ÛšMOdi´–’„´B‰F%IÅÖæ—wøã*!Š)" Ï hääx¬à-û*//bë¢3Á½{÷ò²í?Þ !TGߊYj¥b£„H[˜)õEÆúùTª ²žµäK!])¡âX{3…Ò†|KvR ¡,à±/fŽ®Ù¾u›Ü|ÛSëªÍ˜š«!9¨œõ›ºÄÝ÷ÓØ4pÒËÓ—‡]Nwˆ[FD–õ¹K“›óÍ© -Íéq€µ€LŒeCd’ñɪ$Öºgeû+‰´ìoed¬†k/OÏ,o4"ó…ÿö«#Kî`IN&&é³u‘ÄuBhéðT¥XY)!˜ˆÈ’e#ˆ@˺ZF¬±Þ¹ól!„`Ãs#yJÊ^ÿ¦õzcWF9ÓÞ§sëî­çÖÝe:VëéÉ1„žÄ†5}DºìRåRÖËB°ßl´õ:Û›/X&A„«íY"Ãb¶Rï Rîi+ˆ€«z@ש^3í†ìäëÙùºÄÒ½Ä ·W «%È 4Q_ßòÓ†HO{˜ˆ ¤`¶ä ¥Wu·ï/Ï×;Ï^œ\ÎÜéUï~ç;\Ô+s˜#ë·Ôl˜ ­—oÌÆ×JÈ„.v¼í‡¡æ†;ÁlΟꛯ6Ú{{:))Œ$ÁÌ–¤€˜(̯´ÚÊ5«Wž¶šHi"€Q‚ʵz`LܪðâMpâO­µÓ³ãõU×þÓšž hksé`ßôôÜí‰f%`a™™I0`ÑœKW®h;<[œï>}ôÔ]’#ÿŽÛ¸„G°t¼^®¢„Á^¶.•Ÿ:þ §\m·ntÃ;ujèÖ™ÂüŠUËó'²ÙpŽ®ÖÏ$Ø23[–“S³Mi÷´]جñÜ=LLº‰1uâO]4Þ 圬֢ÕZ‰×lb¬éé:bêù‹W¶Ãª…Ö­´ÄÌÄííMckúÚ÷7¦ÓÉþáà%”g ½8L&ì*0ƒ8#ÖaWiâÒ9š+Î`ï¡QœŽÖ!ªÇ¹u}‡ÚÚš¯ðÕz ˆa¥µÎŽ\°$*«oYyäzýT,¨\nå“7²ñ†¯Å/ïÿËÒ²­¯V¢­#;ï„­d")ˆ…ÏŠå™$—M•Áì‚X1AI°ÊÖÎvw——o꿃¾üÒ¼øOÃ(7-ƒFl”‘ÑÚØJ-sua' ðÅýWÄñ‘9¼kû-hnFèR‘ƒöi'–®N&&ç–fË}]ùBOÍ !Œ¬ÐÆ8›gƺkµz¸ïSO=õº6¾î+1‹'?óJi¾öŽÊLy2ÌgXŠZcyG~¬VnüÃøØìÃ$åþ®¶ü†ÁlÙ¯Ÿïô‘GhãÆ͸ÿÎxî+ßÆ‘‘S£å6FLÄLÄ€`†´“Ž;‰àW~f'îܲ'Nz´ç+µQgמféjkd& ¥¶±‰é­MéÔ߬Ì7 „RŒ˜MÜb±¶ ÖùÆm°¾áÆÈØÁ¯—ýÕ¡Õóõ¨mEG縖F*†`xB!ÛšÒÅR9]œ­Þ-…ªf2AU@H¯tl +·üØÃï!­” xçëñØ}[ð#ýXÝ.ÑÖ©I̢˙«S³¢·µÑh•³^µ4ƒÍý·¢³cîÿžLâF=ñ:Æ$Éh|j¶õòha ôÝ}Ö¬ü–¤4 ¥ŒÑæäðè­qÔhìÿÔOûFÞ_xê)t <6©aîi4ª•ŽL¾l`¤TB«¥…í-ùósårjffî®8JTsZÌgËÇ~ü}ï}ÄiiiÅäÔ$>ûüg°ÿÀ>œ=wÖ²iPÏòvüÈýxÇ]tû– XÖÑL®d¯X( Z­bÍš5ÈåšÐÒÚFÃÇ_nm+Œº'¦ŠëBßyyÝúî¯ ’Ú†6R c´1ÎOwΕ*ëã:ÿÕä#7ÜZ&¿P[6ð^Žæ.?ôÆÒžÒlŒ€T‚„–$:[›F*µ$ž›¿=—\ض¢‰Z¸ÿAŠ¢ßþÇ—P(Î&µ\ÿÁZ#N¦'ƼáÓÇœW^9ˆ‹/r£Q§ÖÖVlÞÔ;î¸k×®…µžï£³£‡”W&fÚ/„ÛœKÿÝúõÝß”‚´%ÚJ#NLq®ŒŽÍÜ$ô#Ÿù™¡¥Ø¶ô fÚ¾ûùŸTŽ³lÚå/eó)-´vIøŠŒqÀ‘`gnzjÃj:ü»=ºKõôôâÊø>ÿÏsÙïÙWK­‘b†’\ Ýúd›“Z]=ÛÝðÀÜÚ¿·ö÷ ´¶´áüù|ñ…ôˆØúá\Kûi‰%°”1Û†ž+ÇrhøÊÛâ$;ð©Ç¿´ÔäŠ7Üþ?PÏù­_ÑZ׆όÝSž¯»¤ßŒl&‡Žöv1tü•5±ÛòbÌA]1 3L©8òö$I"QÃóÇþì}‹mäþËcǾe·Q¾Y{n(újÞý Gݤ¶¼\ilŸŸ/«imÒÉ¥=òž÷©t*é™)¼ôÒ^Ó™/7Ò·ömÍïÆÐÛzœËtä¨ãÁûwªï~ÚÛ;P«Vqzø4¾ùÍo˜W•z2R ºŸh|¾0¶~ÕªU"›Í¡³£Sœ<ñʺºÌ¾xbh~ÕÄTq«fœ)yùÏžyæ'oÊó×äÆ¡ÈÙO>üü¿ð¹·ÍÎÕvêéK»ÛVµ‰å]ËQ*ÍâÔéSÐF›ZjÅÞüÜws’òÃétZÞûà#²··B¹2sgÏà•#‡LafFZéŸi«¿Tɬ9Ɔ­ëWŽ»sßýñ¡¡!™Íæ°bÅJ´µ´ŠÉ‹§>\,¶~ _;øìOÿãk¶ïoBþErýžüƒÕ©ÆÇæçd[kÆÆFñÅ=_!’L&'î}×½ò–ž^Àü| Cçqøè37[”,ƒ#uo՗潞![¡„…ek%™–ÂwžHÉø‘v> z{ú0==…ÏýÅçÌÙª¿ýÓƒ¿vø­êþ¦ðjYªÿRWWwvt¢PœÁðÙ…!8ÎàÁrºW¬3c®4‹“§Nâر#ºTšWìk™ _¬ú«ÎÂBH±µ†™ ¶:W÷/:no:÷¾‘‘d39,[¶Ë–u0Æ'~ Àî·ªû[fÀÇ?þñ^¡xøç~öý2ßœÇèåKØ`?îú¡»±rE7¬5˜›Å‰“ÇqìøqS«VD ÿŸçäŠ=u¯g"«%–óÕrªQ3a½ÑÈÖªQ³¶6dˆÆ;WŒ tæè÷¾ë^µºoŠ³<ÿ¹Ï«ií‡>ô¡Eßô,UÞ2„âÁîîUÜÑÞ‰ÉÉqA€Gâ§`ŒÁÔÌ$Ž;Š'Oš¨QÓuoèÄLûþ©(˜÷ý¯®ka±ÏLDS¬ù€òLalf(³.jc1rit™lÝ+VaÅÊn¾ß¢.\5ÅÙ"jµ*<χçùÃùælÚ¸™8ÌŒZ­Šùò¼, ·LOOöŒ^}hjjJù¾O÷?p¯¹ÿûFÑG´Ö§£8:Yš¯ }û›ß>vìXTªU>ÁàG''&‘3X·vÖ­]g†Î = à¡7cÆÍ2€ÐÇ~ûcwºJ~÷Oþ"ÇÁÈ…³8tè%A"Î “Ê •N! 0B|χçð}ÿêÀsr˜-ªµæçK(f05=Åc—/ëÉ©Ie­% Q£õQ©äÀŽ;°aý&èDãÓÏ>ƒX›»?úá~爵KžÝ èÚá)ùô¦M›MSS³<{nÓSÓÖò˜”ÂaævB˜0šL&ã¦Si¤R)¤Riø0Cß÷ø!|?@†hɯCÿæ-À±Ö¢V«¢T*ÉB±Ð3=5¹êÜùÌÍÍ¢03ƒ‹£пq 6lÜdNŸ<ñ4€{_eü’@X èÕÇSO}ô/ð¾ñ‹ø @À¹‘3xùå}ºPœÙ÷Ÿ?ô[ ­[·fú×ä[óë|?\øîFå8ë´€”Ò¾oÓÙŒ†)¤S)¤Â®ïŒ`‚¡"B„áÂÙ÷rŸ­µ(Îpzø$6­ïá™Oÿ)’(yçG>2øÒUãoømÁ5¹éà†ÞÓ[¶šl6'O @±XD©4§ÎŸ?ÿß8èСCC‡pâêc€Ù¾}{°mÛ–µùÖÖ5®ã®+Í—7+)×1¸¸Ê˜00©TÚ Ã«†‡<Ï[`Œ”‚© Ë Éç/žÃm·ãÖ[·˜#Gü6€·]§ò Ax#\ïýw{÷7üÅ_F¢œ=7ŒÃ‡›É©©£ùðoíºîþëëçëÊ×~Û­[·f¶nßÚÛ’o^ÁZÏó6H)6h¾ Œ‚€S©”„‚ @øp]ÌÀæ·Âs=üé3Œ$JüÈGÿ–È‚7bÀ÷Þ±cù¡ÿ_·Ý¶Ý¦Óqôøa”J%‹EyáÜù?ÂÂÒZca ¿vÐ ŽïË¡C‡pèС#þîšâýýë3[¶ÜÖÛÒÖÒ—I§ú|?X¯µ@îÚ³7®ÇÈù3¸cûݸmëmö•C¯<½cÇŽ¿ß»wï’bÀ’»À»Þý£[k¶lE¥ZAµZÁÅ Œ1æ̳Ïþùw°ŠÚ¸ÎHu˜k€ÈEÎt`×Ê|ìØéʱc§8‚Wy³¿¿?70пzSÿ¦ç®\™€rrjÛ¶Ý.¾rpà¾ï|hïÞ½_]Š]Küfh—Üvû€€¾¾Õ¨×k¨Vª(Í—pþÂ…>ó'Ÿ~ Þ5õë ‹uWË«½v= ¯ùï¿ôä÷ôôüq:F:F¦02rШ%ò >î°DlÛÖ¿>ÑÉß”;uêÔ̵¼|kMék_ýúsXr×}7(_O×뇲WŸ¿_þÚW¿þÜ/<ùÄÝqçŠÅYÔ pÉ÷ÅüŸ üºòf§Â7òô¼½Ôö®˜×Î7*¿©·BÿR_.•îKio)lxÓ_/ÿÚŸ¿¾^Ÿ£°þMþMþä›x{yªü%YIEND®B`‚connman-ui-0_20150622+dfsg.orig/data/icons/network-offline-symbolic.png0000644000175000017500000001140312541725135024236 0ustar nicknick‰PNG  IHDR szzô pHYs  šœ OiCCPPhotoshop ICC profilexÚSgTSé=÷ÞôBKˆ€”KoR RB‹€‘&*! Jˆ!¡ÙQÁEEÈ ˆŽŽ€ŒQ, Š Øä!¢Žƒ£ˆŠÊûá{£kÖ¼÷æÍþµ×>ç¬ó³ÏÀ –H3Q5€ ©BàƒÇÄÆáä.@ $p³d!sý#ø~<<+"À¾xÓ ÀM›À0‡ÿêB™\€„Àt‘8K€@zŽB¦@F€˜&S `ËcbãP-`'æÓ€ø™{[”! ‘ eˆDh;¬ÏVŠEX0fKÄ9Ø-0IWfH°·ÀÎ ² 0Qˆ…){`È##x„™FòW<ñ+®ç*x™²<¹$9E[-qWW.(ÎI+6aaš@.Ây™24àóÌ ‘àƒóýxήÎÎ6Ž¶_-ê¿ÿ"bbãþåÏ«p@át~Ñþ,/³€;€mþ¢%îh^  u÷‹f²@µ éÚWópø~<ß5°j>{‘-¨]cöK'XtÀâ÷ò»oÁÔ(€hƒáÏwÿï?ýG %€fI’q^D$.Tʳ?ÇD *°AôÁ,ÀÁÜÁ ü`6„B$ÄÂBB d€r`)¬‚B(†Í°*`/Ô@4ÀQh†“p.ÂU¸=púažÁ(¼ AÈa!ÚˆbŠX#Ž™…ø!ÁH‹$ ɈQ"K‘5H1RŠT UHò=r9‡\Fº‘;È2‚ü†¼G1”²Q=Ô µC¹¨7„F¢ Ðdt1š ›Ðr´=Œ6¡çЫhÚ>CÇ0Àè3Äl0.ÆÃB±8, “c˱"¬ «Æ°V¬»‰õcϱwEÀ 6wB aAHXLXNØH¨ $4Ú 7 „QÂ'"“¨K´&ºùÄb21‡XH,#Ö/{ˆCÄ7$‰C2'¹I±¤TÒÒFÒnR#é,©›4H#“ÉÚdk²9”, +È…ääÃä3ää!ò[ b@q¤øSâ(RÊjJåå4åe˜2AU£šRݨ¡T5ZB­¡¶R¯Q‡¨4uš9̓IK¥­¢•Óhh÷i¯ètºÝ•N—ÐWÒËéGè—èôw †ƒÇˆg(›gw¯˜L¦Ó‹ÇT071ë˜ç™™oUX*¶*|‘Ê •J•&•*/T©ª¦ªÞª UóUËT©^S}®FU3Sã© Ô–«UªPëSSg©;¨‡ªg¨oT?¤~Yý‰YÃLÃOC¤Q ±_ã¼Æ c³x,!k «†u5Ä&±ÍÙ|v*»˜ý»‹=ª©¡9C3J3W³Ró”f?ã˜qøœtN ç(§—ó~ŠÞï)â)¦4L¹1e\kª–—–X«H«Q«Gë½6®í§¦½E»YûAÇJ'\'GgÎçSÙSݧ §M=:õ®.ªk¥¡»Dw¿n§î˜ž¾^€žLo§Þy½çú}/ýTýmú§õG X³ $Û Î<Å5qo</ÇÛñQC]Ã@C¥a•a—á„‘¹Ñ<£ÕFFŒiÆ\ã$ãmÆmÆ£&&!&KMêMîšRM¹¦)¦;L;LÇÍÌÍ¢ÍÖ™5›=1×2ç›ç›×›ß·`ZxZ,¶¨¶¸eI²äZ¦Yn…Z9Y¥XUZ]³F­­%Ö»­»§§¹N“N«žÖgðñ¶É¶©·°åØÛ®¶m¶}agbg·Å®Ã“}º}ý= ‡Ù«Z~s´r:V:ޚΜî?}Åô–é/gXÏÏØ3ã¶Ë)ÄiS›ÓGgg¹sƒóˆ‹‰K‚Ë.—>.›ÆÝȽäJtõq]ázÒõ›³›Âí¨Û¯î6îiî‡ÜŸÌ4Ÿ)žY3sÐÃÈCàQåÑ? Ÿ•0k߬~OCOgµç#/c/‘W­×°·¥wª÷aï>ö>rŸã>ã<7Þ2ÞY_Ì7À·È·ËOÃož_…ßC#ÿdÿzÿѧ€%g‰A[ûøz|!¿Ž?:Ûeö²ÙíAŒ ¹AA‚­‚åÁ­!hÈì­!÷ç˜Î‘Îi…P~èÖÐaæa‹Ã~ '…‡…W†?ŽpˆXÑ1—5wÑÜCsßDúD–DÞ›g1O9¯-J5*>ª.j<Ú7º4º?Æ.fYÌÕXXIlK9.*®6nl¾ßüíó‡ââ ã{˜/È]py¡ÎÂô…§©.,:–@LˆN8”ðA*¨Œ%òw%Ž yÂÂg"/Ñ6шØC\*NòH*Mz’쑼5y$Å3¥,幄'©¼L LÝ›:žšv m2=:½1ƒ’‘qBª!M“¶gêgæfvˬe…²þÅn‹·/•Ék³¬Y- ¶B¦èTZ(×*²geWf¿Í‰Ê9–«ž+Íí̳ÊÛ7œïŸÿíÂá’¶¥†KW-X潬j9²‰Š®Û—Ø(Üxå‡oÊ¿™Ü”´©«Ä¹dÏfÒféæÞ-ž[–ª—æ—n ÙÚ´ ßV´íõöEÛ/—Í(Û»ƒ¶C¹£¿<¸¼e§ÉÎÍ;?T¤TôTúT6îÒݵa×ønÑî{¼ö4ìÕÛ[¼÷ý>ɾÛUUMÕfÕeûIû³÷?®‰ªéø–ûm]­NmqíÇÒý#¶×¹ÔÕÒ=TRÖ+ëGǾþïw- 6 UœÆâ#pDyäé÷ ß÷ :ÚvŒ{¬áÓvg/jBšòšF›Sšû[b[ºOÌ>ÑÖêÞzüGÛœ499â?rýéü§CÏdÏ&žþ¢þË®/~øÕë×Îјѡ—ò—“¿m|¥ýêÀë¯ÛÆÂƾÉx31^ôVûíÁwÜwï£ßOä| (ÿhù±õSЧû“““ÿ˜óüc3-Û cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅF.IDATxÚÄW[Œ]eþÖúÿ½ÏÜï3g†v —)S†6h¡D¨è3ˆÆ”Dôi^,¡‰‰‰ÆŠš‘¬$ñžÔ¨X¤VÄÚb*I‘éÌ™ éençìsÎÞûÿ×òaŸsæ´búäNö9;û¶¾ÿ[ëûÖÚ¤ªøn¾ù­¯AÕ @ ªtå ˆuww´Ì0‡ª¸&äÍo\]+¾×ÛÓÿ¡Á‘U»ÙDÙ»7ÈQxñw¸íŽõìÆâÅ" Ó5­T¨*r¡E_kŠãÇŽò¹ó‹_¶›ÝJPSQ -îÙº‡¿w ݬák¦›ˆ°´\¾ahn^<·»)Z  ‹sN<†û{a-ãZËÇFTIP0³g6›@®fõˆ(ÖJUX³ ºì„R–RÌÄ8q ¢K‹ðh® ï¥(†1\;OQãp£”D€ˆ"NŠQåJ‚µ(óUl&IUÍvkªÖTåb‚ 0Yà¦D0 ¼¬G1VÖ+(FUĉCš¤0Æ\¢[â\zG.Ìí¢LzaÂ]gç ØÖ—À˜Ö˜ZÐl½ÌççK+F±TA%vA`ÁD¸r…¼êì[V¼ñÖ¿ðì+ûA`7U@E®ÐÓÝûÉþ-7…_}îÏ,ƒ>@ËW»–zÁ@o'=t ~òU¼s.€a¨B½ÏJ‰¯ 7Ø€ß?·Êñúà¼àZ]NDñÎôÄhm Á6“$Aª`bÉ%OÖk@™ ©”Ê >( ›Zl-µ\SC)ªby%Ah*‘ìß{ÄIƒI»¡q ŽÖ£ÒÈmØó&®F”U{’zD•ŲƒÁÁ]‡{ö/Y­f5 ÀîmƒøÓ»‚ôRƉC1Š³\S¦e£áDàš¶«qŠ•b«Å ¢(Fœ: õuA•°o¼c;n€ˆÀ«u•BLŒs“riµrÚÌ@æR¥J"q]ßÚX­(P©¦X)VQ,WáœT¡ÄÙ303f óX[/£X\Ç¿ÏÌ_ŒƒüéTh!hé ¨kSŸö·„»_¤ê2¬1à<¢ª3ƒ™AÌeÔÅ©GTM'" 6!¨ D*ËÃÎc˜˜Øƒ$Ž±ëÆ…¾oŸÜþ»¿Oÿ6wýù´ºZíì½~/ ?xñý›¶ÙAãÔƒª)¸f2†(à¼Bjbƒ sLÕZqà2œ9!1ÎÌÏúR‰ԒˡŸ‰½{¿ðÇW~õü…™S¯÷ŽŸ>?sê/Ë ï5¥@’ œ¤`# b Æ ËÔ€ª"P•LÑšé›™7¼‚•½$œ:‡8)£w0o><ÚvÝ=Ÿ8T.ü|azf}Ë–û½ï¾¿k7\NQ©¤ +0FA†aŒ€Å×XÉlÛ{Ÿ9›¤.­Ä!N Dýƒ4˜Ï£R.CÈårðÞÙŽÎK4Ú¶küæüÉ'¾a¬9hk÷u·áÀžë ÐæÒ¬ÑËm>V…Aog;r¡E‰[GFQ*•àăÃi’‚ˆëÌaÛöw?óìÓ÷Z(—c?¶µG¾òT´áß@mµ5®›ƒ²10¤MÍEaŒÅLaï/ÌWSÆ)Q Õ@æ‚*€6 qö?§Ï,¤©ûö /ýp9“@‘²5Ö¥î®ÁmA6¤Èl` ãâò VÓ\…s Uφ‹Ëo%N'/¼üÌ…ž™™»•øF|s#ñĦo~þŸ{óÃY üúåß›)L›¸mß­·?úèç¾>888¸{|7˜ Tµ ,--áÔ»gâÓ…Å—§£®ãù{ÇÈ™Ž–[WN—»~üÓ¡]ù¡çÛwìèÑj ²AÆ“KÁ¹V½__ýÛµðÚk¯˜¹…™ullçg&&n¾??”O½w‰ßh‡Î â$Ñîîºã–=ÕÒñ.š®-oÿáţưܱ÷gŽ¾ªø[ÚöìéivvBææ²££ 4Eûøx×òì츀#GŽàìâü§†G†ɵæú ]ZX[\ZÌé¨ÑTU“$ñÖZCLÔÓÓ•o½sdOWZ ×—Þ|ò…ïŠ÷Þw "´tu¡õé§QyòI@ëã£29 )—À[ˆ¢â®ýûöÿ`dËpgغÑûëSO6ã1â$FT*A|V¨mímð.AwïÄ€wþ@anáÓ³ ³o …a ÖBææPyâ ´?õ :t27ÎÉÜÍ~÷úmÛ:Sç >£šÁ`¶`²0Àš Ѷ¢·§ÝÝ=èíéE`´·w„à`çÎ1,ž=û¥••å®º9]mãÆ@£¤„öÖ.xñØh~Ò ‚™Êú¸1`¸6¦ ¬µpÎÁš>upÎ÷©h œŽ¢õðaD=–¥àðaT&'rU@-ÄÕäÁŸýâ'¬1pjB"HݘÁ†)Pf£¿*AÚAUTÁDðL„µâѹ݄!8MQœlaurœ¦èÎåðÐaÀ3`JD Ù«3ókš` Õ¾=´»qEêîh,OMáÕÔ>T(¸ÖíÛ­/—|>ó€r& qnzZN{é„CÙRû¨hvâÌši#=M?õ6e˜Q‰Êxæç¿DIåõW¦¦ÎOMÝ$€¿,÷f˜ÿ+pô¿Ì×<{ÎC¦gIEND®B`‚connman-ui-0_20150622+dfsg.orig/data/icons/network-wireless-signal-weak-symbolic.png0000644000175000017500000000667212541725135026665 0ustar nicknick‰PNG  IHDRóÿa pHYs  šœ MiCCPPhotoshop ICC profilexÚSwX“÷>ß÷eVBØð±—l"#¬ÈY¢’a„@Å…ˆ VœHUÄ‚Õ Hˆâ (¸gAŠˆZ‹U\8îܧµ}zïííû×û¼çœçüÎyÏ€&‘æ¢j9R…<:ØOHÄɽ€Hà æËÂgÅðyx~t°?ü¯opÕ.$ÇáÿƒºP&W ‘à"ç RÈ.TÈÈ°S³d ”ly|B"ª ìôI>Ø©“ÜØ¢©™(G$@»`UR,À ¬@".À®€Y¶2G€½vŽX@`€™B,Ì 8CÍ L 0Ò¿à©_p…¸HÀË•Í—KÒ3¸•Ðwòðàâ!âÂl±Ba)f ä"œ—›#HçLÎ ùÑÁþ8?çæäáæfçlïôÅ¢þkðo">!ñßþ¼ŒNÏïÚ_ååÖpÇ°u¿k©[ÚVhßù]3Û  Z Ðzù‹y8ü@ž¡PÈ< í%b¡½0ã‹>ÿ3áoà‹~öü@þÛzðqš@™­À£ƒýqanv®RŽçËB1n÷ç#þÇ…ýŽ)Ñâ4±\,ŠñX‰¸P"MÇy¹R‘D!É•âé2ñ–ý “w ¬†OÀN¶µËlÀ~î‹XÒv@~ó-Œ ‘g42y÷“¿ù@+Í—¤ã¼è\¨”LÆD *°A Á¬ÀœÁ¼ÀaD@ $À<Bä€ ¡–ATÀ:ص° šá´Á18 çà\ëp`žÂ¼† AÈa!:ˆbŽØ"ΙŽ"aH4’€¤ éˆQ"ÅÈr¤©Bj‘]H#ò-r9\@úÛÈ 2ŠüŠ¼G1”²QÔu@¹¨ŠÆ sÑt4]€–¢kÑ´=€¶¢§ÑKèut}ŠŽc€Ñ1fŒÙa\Œ‡E`‰X&ÇcåX5V5cX7vÀžaï$‹€ì^„Âl‚GXLXC¨%ì#´ºW ƒ„1Â'"“¨O´%zùÄxb:±XF¬&î!!ž%^'_“H$É’äN !%2I IkHÛH-¤S¤>ÒiœL&ëmÉÞä²€¬ —‘·O’ûÉÃä·:ňâL ¢$R¤”J5e?奟2B™ ªQÍ©žÔªˆ:ŸZIm vP/S‡©4uš%Í›Cˤ-£ÕКigi÷h/étº ݃E—ЗÒkèéçéƒôw † ƒÇHb(k{§·/™L¦Ó—™ÈT0×2™g˜˜oUX*ö*|‘Ê•:•V•~•çªTUsU?Õyª T«U«^V}¦FU³Pã© Ô«Õ©U»©6®ÎRwRPÏQ_£¾_ý‚úc ²†…F †H£Tc·Æ!Æ2eñXBÖrVë,k˜Mb[²ùìLvûv/{LSCsªf¬f‘fæqÍƱàð9ÙœJÎ!Î Î{--?-±Öj­f­~­7ÚzÚ¾ÚbírííëÚïup@,õ:m:÷u º6ºQº…ºÛuÏê>Ócëyé õÊõéÝÑGõmô£õêïÖïÑ7046l18cðÌcèk˜i¸Ñð„á¨Ëhº‘Äh£ÑI£'¸&î‡gã5x>f¬ob¬4ÞeÜkVyVõV׬IÖ\ë,ëmÖWlPW› ›:›Ë¶¨­›­Äv›mßâ)Ò)õSnÚ1ìüì ìšìí9öaö%ömöÏÌÖ;t;|rtuÌvlp¼ë¤á4éĩÃéWgg¡só5¦KË—v—Sm§Š§nŸzË•åîºÒµÓõ£›»›Ü­ÙmÔÝÌ=Å}«ûM.›É]Ã=ïAôð÷XâqÌ㧛§Âóç/^v^Y^û½O³œ&žÖ0mÈÛÄ[à½Ë{`:>=eúÎé>Æ>ŸzŸ‡¾¦¾"ß=¾#~Ö~™~üžû;úËýø¿áyòñN`Áå½³k™¥5»/ >B Yr“oÀòùc3Üg,šÑÊZú0Ì&LÖŽ†Ïß~o¦ùLé̶ˆàGlˆ¸i™ù})*2ª.êQ´Stqt÷,Ö¬äYûg½Žñ©Œ¹;Ûj¶rvg¬jlRlc웸€¸ª¸x‡øEñ—t$ í‰äÄØÄ=‰ãsçlš3œäšT–tc®åÜ¢¹æéÎËžwç|þü/÷„óû%ÒŸ3gAMA±Ž|ûQ“ cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅF×IDATxÚl’Oh$UÆ¿zý:ÓéIOBï²™AÈÑȼìä² :+„€"¸—xróêI¯›ƒœ»xÄ›B4 xºFaBoÖ`Ø!Ù¤{'o&ýòþ”3ËòA]Š¯~Uu:¬¬¬¶¶¶nžžÞãøå±±±B ï=k­ÿãøGcÌo­Vëo\ˆ:¼÷ØÞÞþ ^¯¿Ñn·oÍÌ̼ALDf†R*___ïæyþûôôô—ºBHí~¿wqqñÝ$I® !Ðëõ „Àp¹Öjµn—ey{ww÷fžçý4M?¥ÕÕÕ_æææîxïa­E§•JåŸ(ŠI)53³÷¾¦µnh­›Ì\»ÝîšLÓ´wpp€‰‰‰®”ò)å¯RÊaž„ah°µvÜ9wÝ9÷¢Rê-kíûý~ÿ¹4M­,Ëòkççç? !zEQàääRJLNN­µ!¢~µZ}`­ýi8~ÁÌïi­ö™ùk­5ʲ3G•Jåf–eo&I2åœc¥ÔñìììZQ;Bfæ‡Ì¼JD@D`抔òÃÁ`ðZÇåååvŒ1vccãm¥ÔÃZ­¶î½ÿ€ÉÌ£+¿`­ýh~~~! CäyŽ0 á½ÇÙÙ™l6›‹eÙ+þÐeæÿ7¸Ø"‹¢hwooo!‚?¤”÷‰è‘÷žœsMcÌ3ÏU«ÕÇJ©ƒÑ'ž”Ãáðãñññ¯Æ_µZíÉÔÔ¬µ8>>Fžç7_WJmÑ`4ô,Dtà¨( ìïï#I’Q EÑ!}‡Kº €1eY’”òÕ,ËÞaf®×ë߃ûÏ&óJxïàycÌgKKKwœsØÜÜl !Vd—ý‚ˆp¹9çXJ f†1f‚™ã É«šD¤Æç;;;׬µqš¦÷”RO®òþ7¬Ø{ú“\‡IEND®B`‚connman-ui-0_20150622+dfsg.orig/data/icons/nm-adhoc.png0000644000175000017500000001036412541725135021001 0ustar nicknick‰PNG  IHDR@@ªiqÞbKGDÿÿÿ ½§“tIMEØ ;¤ù6-–IDATxœÕ›{tWÕ•Ç?çœ{óKòKBÂ# Ê*R@mu¬ŽVi­ƒµ]03eµ*vÙv,µ[ µT§Uèªí´ÚY€.U¤­S,V h—­/äU¡¼ZE‚!ïß/¿Ç½çìùã÷ @(‰æ—Ú½Ö]÷qνçìïÝgŸ}Ïþ^P_ÿÝñÆ°ÎZ;œ‰Ö:R·hÑý´Pm¼ñ2;{Óðáµ5—_>¥TAÚ±cgÉúõ/Þ | :nÜ83dÈ^Ú¸›Ã­}Ö€ÖŠœÁøñãX»v}´ÏÜGâu=I¤¾¸pUŸ7¢€sN¯éóçö…@:&ŒÅàAå­1Ze6£1Zã…1 ­tö.A$»ï¦_þæ’i[P%>ˆxÝ]´Îᜠ• ¥5J+´Éì•Êk¥@rŠg€Èl’Ùº…äÃ%Ý€Ê*mLFayãZ)´ÖèܹVhQš¼Ò NpâúU—÷%Ý (¥QY ´ÖY+ÈZ@~Ÿ±O+ÁeMÀiÐÎ!…™PúTN@Öä»(oLîë¼­P”R£-–¦5ž¢3,ÉtØßúôZº ûfsÛ´Qy@´ÉX@Ggš¦öi\Öw8ç°Zëîÿ¡’ú”FåÆ}W ŒÂhM*t4µ'H¤BDÀ÷ Îi¬u8§PÖQ ˜ªO¥{ÈcpäígÍß9hê H¦C…_äeœžÓXçPJeP ì‡ d@a¸@ˆ§BZ)|?s«HÖä­ ¬B–ÌÌ`ät ¬ ,¡í¹L@d2›ïtv!«¼™`H#ZçþA- õp J$ëéu&èÉ ÄNg³à\ÞrÎÐÚã[ÝZuìµ{¾0¹¥þ.ær%€æ¦fš›šû¬‘SkäÓi{܃ëVlv,ßtÔ%l%ë*ö¶>W_ÿÉ‚Ï£Gàyš—üBŸ7RU5ˆX,À¿~l8¾Qø^6”΄˺3e‡·ÆƒáZ—¼ý^|~ûi•·l㜥sÎ|±Ï;ÔEŽîóFJJJó¬ýÓ!d§H…oEž¦¼ÄgHE„OLÌg¦Õð¶ÆÑ[ßn];ÙÆ/Þ7çÌÇû¼SYÉ b»ví¶&Œ7…X‰Ç;Ù¹sÚ˜DK,yE×2mŒ ÜÐ’¬Ý}0ö™—w¾øâUŸ=ûšÚSfsânD~^(¡îºë®q"fs¶¶(¥ 7Þ~ûÂeǥؼeWF|ó¹E³&ñûí<·¹´š°äê©» Ñ/`áÂ…»'ªt÷=w®ÖÆ›–ây>¾ïáyžä8³ïw¹í–…Ä„”BŠŠ}@]Ÿˆ€gþMñ¾s÷Ý3•sÓÆŽu‘6Ê3Fû¾)O&ÍÆxµNAPQ^N"Ñ JSRRL<Þ‰g Ñh#GžÆê5¿jK&Ó­Z‰òýHy"™hzwïÁW‰D ­ÿºàÖ[ÿûD¹ñá #°ú’±ÃÊH–íûÚAdËÒ«§í/(¾™íy“'O"RêeæzÏày¥Ñ’Jß÷QZᬥ¼|ñx¥¡4ëÜ|Ï#t–0Hãy~E¤8U8DmT嘱£Æ4neß¾}Ô××/¯¯¯¯»Î˜ÐüÀóTÉYcªØöN‡Ú’XgR(åôܹs#‰dêì«®º’Ó'MD)…‰P)FÅ ªAhOãû§:Š¶X #jG0¬f8íñ6>2~Ê¿È£ºz¡”E£ãûx¾Ç ÁU\yåg1ž— œûdw©[¾i&Š«Î=­k·¾‡ˆì>°í­‡ €WZZqN†¦¦f(ïx!™H¢´Â÷ŠØß±Ÿh4ŠU–mÛßÈï^{ãåüqScåe´¶´"Jð´! CÚ‚6FŒ¨5»vîºx¢k'æ/ß0Qà‡U•0qx9Üy˜öD@¼­iÞÊ¥³ táEŸ8÷;`@¥)//gܘ Ù¥-—ù‡Bõ(g`ÅhsÔýZk<Ïç¢ /ôvüy×e]ëÏ}ä• ¼_–FtÅÇÆ䯇⼹·0•üéƒó>õl!”î*ç¾ä¬-ŠÇã$I‚ $B ÄZG„ØІ6_ö·6gå¸ûS©4ñxG"‘¨­««ËÌ8"Ê Š–kÍÄi£ªèH¼²«‰Ð¯üá©%·ù°,¨xAŽY·îÖ¯!UèÆ@‰ˆ+…0Ŧ›õ¹q5eh­x}O3é0lؽéwW¿ñ»•í…ïO&ò‘Ù}¡%ÍóVlþ´ùÍ3ª:Ê_â4u¤Ò {·_õXýìßÒo²‘`ËMo%Ö½^ñM¬-§±=Å;t4¿wÛÏæ_zôûªåõl(ë~á=hlMñTȾÆNÒ‰ø?›éýô£òðw ¬È<LSS†6°ç@œ0 ·>ÿèu@¬¿ûÓ¯Ì[¶ùZ`öðA¥TE}vˆØ°iëK«æìüÃó ýÙ—œôóØ0X+ù~I‘aÜ°2þr(Fg2´wm¹aýC÷l%³¨ØïrÂUá¾ñ½… ƒ¦Œ¬$– y¯-EвoÕi²ÇÜqÇw®,H›"ì+õõõNT§_fÿüñ¶²âhúàЊâ²éS†ò«×öïhm¬8øb9"Å…l[kÝì\0¦¾¾¾µ»ò~±€’ÒàÓ"”M¨-'–‰'CtãŸ7ùþô[oývÁÚî¼sñ@0Ó§º«Ó?C@ÉX†(¦=à+ûžçyðó5o°öµ=}Úäç.žÌeœž=“¢Õë$”70ŠÆ¶ÓFWòòŽ&RÑêO«àð?+_åPsœŠÙ¤l&û”IÓgF©Ö=­-øžîÀ‰¥_Ø÷Û=/ ›>âÍ?î<|Æ´ÑUÜtÅž~®qèÝïP^!­Š}Ú) ŽÖ£ðŽ¢åd’1*ﶲü“.ÄŒœ¼º±çˇý2 ®\9Ë®{òÞÙím-ë¼f7Ïnj ¼ÄÏæ2â²”,#Eåy h%lh<£ñ<ç|c0Æ`<ƒ§M&ußK¿Þ'P_/:vêÖ‰²5Q"úÉ¥×Nùu®Î›kWízsíª¯ÏøÚ÷Îo><å²JiûçÁNæÊ5 Õ º IC©lv:“¦7:“P@gé9N ZÀiGoòò€›ÞRíB7¿]mž uØ£­›‘v?ó“o§×®¿þ«3‡Œw3`òUsŒ¥0Qr¦ß•–“å(‘ÍÉ:„0’l&©ôüCòý ¢æ¯Øü gÝb”ê@É$tO,ýòY'så°ˆF£ÑŽ®C7ÇJ¡+/Éè<Kå³*@K,EkGŠ¶Î©´Í'gcÙ™¦'ÒknxèÕA‘[ÅtDî”hâÞ¥³Îëíº]¼²²²­ë‘®c_å•Wæè¡ÐÔ‘¦©=IZœ@ã{`B«Þ1SzÀÍlXóÊÔ¬Íxú5W‹Îµ²i÷žJ0Î,^\2gêj€¹Ë6q° ÅC÷]3õ†\êú[Ë_«±}%Ñÿ×SÐKsø½6lxÄ”óœäœSÌ™89.r6xAœäùÉN ½­Ò7ÜòèÖªtÚÎôÌܵ"¥¾/ð§}¥»ç¢¦ "ªnÅæÛ-ÜÒª`Ko’ù_¾b*/¼ñV/î8‰Œ*çÒsÇö¨êIH§Ü,mö6¯|ëK8™¶rÖ, P·|ó](ê2?ÝQþàýß׫ÃŒóÇrÉÙ}û·NiiÏþÍ8ùÐr!Ž?äKïj%²yÉugnøæòMSo¡ä_î»æ̵½é¤s™U°Aƒzf®…“ r†Ò<ÝåÂ'Q²>wfP7‹È3K®Í(?{öìŠ L-ð½ÈâG}´Û R²9•J™gŸý­”””de*‹ àmeØ)núô‹£ûö¡Œ¦ÈóA+JL18ÇðÚÄã1<ãQ]]MG¬ê!Õ„a@*H3´fñx" P¢Z3ÄŸ:eª¿fÍs6™L] t ÀIW„^unþ‚ãEQ̸éá-™yF¼%y"ãc=Ö"ðåH&8ï¼s9eX UU•WTVUÎÌm‘HñYS§NÑU+Œ>òÚ±’N§Hì:be­8R©äѳ®Tku–!ÕÕ|tÊdƒR3N¤ßIШßgÍ`Ã`ØQçÜ5KæLÞ·ôÚi ºŸzâ©5ÀŠÍ›¶R‰0zÌFßF… µµÃóúé€d2‰M[Úc1bíØбÿÝ}tÆ;iokãí·ß"LÓÐpæÃM¤)5$™H‘H$ˆÇâH(Ø0&Û0dDm-©dòÌúúúÒîô;épÑÎ5ª³¤ƒˆ¾XxßWÎ>\·|ó׏¿ü­û|©‹ÅbŸzüñ'‹pJKJ9÷œó?~"#FŒ d›ç¯¬)kÖrü]Êú¸þm^“ÏçÏ¿ƒæiÖ%W8B‹P.Ÿ@ú¤õñÿé‘;Q …BeØó<”Oñï3¿O¡µœ€‚W.“É—x–+’Í—È×nÉãÝ{h­QJ] k­ñûé\ ¥ÙÃÿìçØMå)½ »ìǶ‚•aÓ4q]åSdÜ2;©<™ÃNعæ,Ãa ÏËbš/Îå9ì8¶m ¤òG–IÔ2¯„.ÃA ÃÅqœË°mÛÇÅ R­ºøYXVÛ¶+¯Øôk¢‘›ÝáÓ¨„°Ì °aGÁ`Ï?ýTúOj""‘áðÿOâ“®ªªz窉›šš>kkk»“H$ìµµ5ºººŠ¦iê¹¹¹ŸmÛÎ__,×××ÄB¡Ð{ýýý—॥%:;;Y\\d~~žÙÙYGDðß÷eVBØð±—l"#¬ÈY¢’a„@Å…ˆ VœHUÄ‚Õ Hˆâ (¸gAŠˆZ‹U\8îܧµ}zïííû×û¼çœçüÎyÏ€&‘æ¢j9R…<:ØOHÄɽ€Hà æËÂgÅðyx~t°?ü¯opÕ.$ÇáÿƒºP&W ‘à"ç RÈ.TÈÈ°S³d ”ly|B"ª ìôI>Ø©“ÜØ¢©™(G$@»`UR,À ¬@".À®€Y¶2G€½vŽX@`€™B,Ì 8CÍ L 0Ò¿à©_p…¸HÀË•Í—KÒ3¸•Ðwòðàâ!âÂl±Ba)f ä"œ—›#HçLÎ ùÑÁþ8?çæäáæfçlïôÅ¢þkðo">!ñßþ¼ŒNÏïÚ_ååÖpÇ°u¿k©[ÚVhßù]3Û  Z Ðzù‹y8ü@ž¡PÈ< í%b¡½0ã‹>ÿ3áoà‹~öü@þÛzðqš@™­À£ƒýqanv®RŽçËB1n÷ç#þÇ…ýŽ)Ñâ4±\,ŠñX‰¸P"MÇy¹R‘D!É•âé2ñ–ý “w ¬†OÀN¶µËlÀ~î‹XÒv@~ó-Œ ‘g42y÷“¿ù@+Í—¤ã¼è\¨”LÆD *°A Á¬ÀœÁ¼ÀaD@ $À<Bä€ ¡–ATÀ:ص° šá´Á18 çà\ëp`žÂ¼† AÈa!:ˆbŽØ"ΙŽ"aH4’€¤ éˆQ"ÅÈr¤©Bj‘]H#ò-r9\@úÛÈ 2ŠüŠ¼G1”²QÔu@¹¨ŠÆ sÑt4]€–¢kÑ´=€¶¢§ÑKèut}ŠŽc€Ñ1fŒÙa\Œ‡E`‰X&ÇcåX5V5cX7vÀžaï$‹€ì^„Âl‚GXLXC¨%ì#´ºW ƒ„1Â'"“¨O´%zùÄxb:±XF¬&î!!ž%^'_“H$É’äN !%2I IkHÛH-¤S¤>ÒiœL&ëmÉÞä²€¬ —‘·O’ûÉÃä·:ňâL ¢$R¤”J5e?奟2B™ ªQÍ©žÔªˆ:ŸZIm vP/S‡©4uš%Í›Cˤ-£ÕКigi÷h/étº ݃E—ЗÒkèéçéƒôw † ƒÇHb(k{§·/™L¦Ó—™ÈT0×2™g˜˜oUX*ö*|‘Ê•:•V•~•çªTUsU?Õyª T«U«^V}¦FU³Pã© Ô«Õ©U»©6®ÎRwRPÏQ_£¾_ý‚úc ²†…F †H£Tc·Æ!Æ2eñXBÖrVë,k˜Mb[²ùìLvûv/{LSCsªf¬f‘fæqÍƱàð9ÙœJÎ!Î Î{--?-±Öj­f­~­7ÚzÚ¾ÚbírííëÚïup@,õ:m:÷u º6ºQº…ºÛuÏê>Ócëyé õÊõéÝÑGõmô£õêïÖïÑ7046l18cðÌcèk˜i¸Ñð„á¨Ëhº‘Äh£ÑI£'¸&î‡gã5x>f¬ob¬4ÞeÜkVyVõV׬IÖ\ë,ëmÖWlPW› ›:›Ë¶¨­›­Äv›mßâ)Ò)õSnÚ1ìüì ìšìí9öaö%ömöÏÌÖ;t;|rtuÌvlp¼ë¤á4éĩÃéWgg¡só5¦KË—v—Sm§Š§nŸzË•åîºÒµÓõ£›»›Ü­ÙmÔÝÌ=Å}«ûM.›É]Ã=ïAôð÷XâqÌ㧛§Âóç/^v^Y^û½O³œ&žÖ0mÈÛÄ[à½Ë{`:>=eúÎé>Æ>ŸzŸ‡¾¦¾"ß=¾#~Ö~™~üžû;úËýø¿áyòñN`Áå½³k™¥5»/ >B Yr“oÀòùc3Üg,šÑÊZú0Ì&LÖŽ†Ïß~o¦ùLé̶ˆàGlˆ¸i™ù})*2ª.êQ´Stqt÷,Ö¬äYûg½Žñ©Œ¹;Ûj¶rvg¬jlRlc웸€¸ª¸x‡øEñ—t$ í‰äÄØÄ=‰ãsçlš3œäšT–tc®åÜ¢¹æéÎËžwç|þü/÷„óû%ÒŸ3gAMA±Ž|ûQ“ cHRMz%€ƒùÿ€éu0ê`:˜o’_ÅFþIDATxÚ\’ÏkUÇ¿÷Î̘7óÞ3/¯©Ôh…(bQŠÁH h]#ˆ ÅE*’U ¡€k—nŠ8¢n"YTKw‰‚à¤B"b¤m¢}1tÞ{q^æ×¹sŽ ólš/œÅ9œóáË9GA€ååe¬¯¯Kg÷÷÷<Ï{jddä„”qžçw’$ÙlµZŸOOOoâP"<ÓétÞ™››{¶ÝnOyžç !ÌŒ8Ž÷Ã0ÜZ[[ûyrrò€-)%Dç]×½èûþ9ß÷Ç]×…R RJ CHY–ÈóQí ƒkZëKbeeeolll‚ˆ`ŒeYŽã츮û·RJ33Q]kýÖúQfv†à~¿¿­ˆè›¢(²,ÛRJ­*¥¾UJݲm»oÛ¶ÀƘªª¯ªêñ8Žç1o:ŽsŠˆ6E8ï8ÎW®ëî•e "‚R FeYBk !jµâ8Fš¦§Ë²|À5àOfþLk<ÏÁÌîÆÆÆë­VëT½^oVUŃÁ ×ívÿš½*¥dfÞfæ÷…P „3;J©Eß÷ßZZZ:3::ú çy¢(*“$éïìì¼$É*]@ ˜y¸å©f³ùQ³ÙyžCJ‰ªª@DȲÌNÓt¢Ýn¿æ8ÎËaÞ°ÅÌÿ98tq3ŽãË–²¼Qïû†×ø¡îÕ·1²ÈŠ'ò,Iúl–e_3sgx‰ÿò4M/‚ñ¡ïú¿î¦»Qájcp7aUÖ‰^¯÷"­ !’áªÉÚ½gÖ­zøÅ+ø´ó ž~x …©ðûîm,ž\¼;oÏ_)D£Ͻ7s$eX–…ëÑua»ö¹ qúÕªbÞã[—ÙÐ/3Þ Wv€wï/€<6ó䙟.<ÿJ»4„տܽqû·Ü„¸¿]Z 8Ò,¡3ÑûÎjt‘yÀnþ³ ]@ …ãbÀ²g²ûÁ ˆNþ€Â㈤Ž;øw/Qƒk¾v›IEND®B`‚connman-ui-0_20150622+dfsg.orig/data/ui/0000755000175000017500000000000012541725135016103 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/data/ui/right_menu.ui0000644000175000017500000000771412541725135020614 0ustar nicknick True False gtk-yes True False gtk-no True False gtk-network False Airplane Mode False True False unset airplane mode image1 False Airplane Mode False True False set airplane mode image2 False False True False False True False Share connection False True False Share your connection (tethering) image3 False True False False True False gtk-quit False True False Quit ConnMan-UI True True True connman-ui-0_20150622+dfsg.orig/data/ui/left_menu.ui0000644000175000017500000000303512541725135020421 0ustar nicknick False False True False Available networks True False True False Scanning... False True False More networks ... True False connman-ui-0_20150622+dfsg.orig/data/ui/tray.ui0000644000175000017500000000041712541725135017423 0ustar nicknick True Connman UI connman-ui-0_20150622+dfsg.orig/data/ui/settings.ui0000644000175000017500000032477312541725135020322 0ustar nicknick 530 400 True 5 False True center 530 400 True dialog False vertical False end gtk-apply False True True True False True False True 0 gtk-close False True True True False True False True 1 False True end 0 True True True True in True False True False vertical True False start start 20 True False gtk-missing-image False True 0 True False start <Name> False True 1 True False gtk-missing-image False True 2 False start (<Error>) False True 3 Autoconnect False True True False start False 0 right True False True 4 Favorite False True True True False False True 5 False True 0 True True start 5 5 5 True False vertical True False start True False start Method: False True 0 DHCP False True True False start False 0.029999999329447746 True True True True 1 Manual False True True False start False 0 True True ipv4_dhcp True True 2 Off False True True False start False 0 True True ipv4_dhcp True True 3 False True 0 True False True False start Address: 0 0 1 1 True False start Netmask: 0 1 1 1 True False start Gateway: 0 2 1 1 True True start start 10 10 â— True 2 0 1 1 True True start start 10 10 â— True 2 1 1 1 True True start start 10 10 â— True 2 2 1 1 True True start 10 10 False False â— 1 0 1 1 True True start 10 10 False False â— 1 1 1 1 True True start 10 10 False False â— 1 2 1 1 False True 1 True False IPv4 Settings False True 1 True True 5 5 5 True False vertical True False start True False start Method: False True 0 Auto False True True False start False 0 True True True True 1 Manual False True True False start False 0 True True ipv6_auto True True 2 Off False True True False False 0 True True ipv6_auto True True 3 False True 0 True False True False start Address: 0 0 1 1 True False start Prefix length: 0 1 1 1 True False start Gateway: 0 2 1 1 True True start 10 10 â— True 2 0 1 1 True True start 10 10 â— True 2 1 1 1 True True start 10 10 â— True 2 2 1 1 True True start 10 10 False False â— 1 0 1 1 True True start 10 10 False False â— 1 1 1 1 True True start 10 10 False False â— 1 2 1 1 False True 1 True False True False start Privacy: False True 0 Prefered False True True False False 0 True True False True 1 Enabled False True True False False 0 True True ipv6_priv_prefered False True 2 Disabled False True True False False 0 True True ipv6_priv_prefered False True 3 False True 2 True False IPv6 Settings False True 2 True True 5 5 5 True False vertical True False start Name servers False True 0 True False True False start In use: False True 0 True True start 10 10 False False â— True False True 1 True False start Configuration: False True 2 True True One or multiple IPs separated by ';' start 10 10 â— True False True 3 False True 1 True False start Domains False True 2 True False True False start In use: False True 0 True True start 10 10 False False â— True False True 1 True False start Configuration: False True 2 True True One ore many domains separated by ';' start 10 10 â— True False True 3 False True 3 True False DNS Settings False True 3 True True 5 5 5 True False vertical True False start True False start Method: False True 0 Auto False True True False start False 0 True True False True 1 Direct False True True False start False 0 True True proxy_auto False True 2 Manual False True True False start False 0 True True proxy_auto False True 3 False True 0 True False True False start URL: 0 0 1 1 True False start Servers: 0 1 1 1 True False start Excludes: 0 2 1 1 True True start 10 10 False False â— True 1 0 1 1 True True start 10 10 False False â— True 1 1 1 1 True True start 10 10 False False â— True 1 2 1 1 True True start 10 10 â— True 2 0 1 1 True True start 10 10 â— True 2 1 1 1 True True start 10 10 â— True 2 2 1 1 False True 1 True False 5 Proxy Settings False True 4 True True 5 5 5 True False True False start In use: False True 0 True True start 10 10 False False â— True False True 1 True False start Configuration: False True 2 True True One or many IPs/hostnames separated by ';' start 10 10 â— True False True 3 True False Time servers Settings False True 5 True True 5 5 5 True False start start 5 True False start Method: 0 0 1 1 True False start Interface: 0 1 1 1 True False start Address: 0 2 1 1 True False start MTU: 2 0 1 1 True False start Speed: 2 1 1 1 True False start Duplex: 2 2 1 1 True False 10 <Method> 1 0 1 1 True False 10 <Interface> 1 1 1 1 True False 10 <Address> 1 2 1 1 True False 10 10 <MTU> 3 0 1 1 True False 10 <Speed> 3 1 1 1 True False 10 <Duplex> 3 2 1 1 True False Ethernet information False True 6 True True 5 5 5 True False start start 5 True False start Host: 0 0 1 1 True False start Domain: 0 1 1 1 True False start Name: 2 0 1 1 True False start Type: 2 1 1 1 True False 10 0.47999998927116394 0.49000000953674316 <Host> 1 0 1 1 True False 10 <Domain> 1 1 1 1 True False 10 10 <Name> 3 0 1 1 True False <Type> 3 1 1 1 True False VPN provider information False True 7 False True 1 settings_ok settings_close connman-ui-0_20150622+dfsg.orig/data/ui/agent.ui0000644000175000017500000011707712541725135017555 0ustar nicknick True 5 False True center dialog False False vertical False end Retry False True True True False False True 0 gtk-cancel False True True True False True False True 1 False True end 0 True False 10 10 10 vertical True False True False gtk-dialog-error False True 0 True False Error False True 1 False True 0 True False <error message> False True 1 False True 1 error_retry error_cancel True 5 False True center dialog False False vertical False end gtk-apply False True True True False True False True 0 gtk-cancel False True True True False True False True 1 False True end 0 True False 10 10 10 vertical True False vertical True False center True False Network False True 0 True False <service> False True 1 False True 0 True False requires information to get connected False True 1 False True 0 True False 5 10 True True â— 1 0 1 1 True â— 1 1 1 1 True False vertical Name: False True True False False 0 True True False True 0 or SSID: False True True False False 0 True True name_button False True 1 0 0 1 1 False start Identity: 0 1 1 1 True False vertical Passphrase: False True True False False 0 True True False True 0 WPS Push-Button False True True False False 0 True True passphrase_button False True 1 WPS Pin: False True True False False 0 True True passphrase_button False True 2 0 2 1 1 True False center vertical True True minimum 8 characters â— 0.0099999997764825821 True gtk-dialog-authentication False True 0 True False vertical True False Previous Passphrase: False True 0 False <Previous Passphrase> False True 1 False True 1 1 2 1 1 False True 1 False True 1 input_ok input_cancel True 5 False True center menu False False vertical False end gtk-apply False True True True False True False True 0 gtk-cancel False True True True False True False True 1 False True end 0 True False vertical 10 True False True You are probably trying to connect to a Hotspot. You are probably trying to connect to a Hotspot. Login is required to get plain access to the network False True 0 True False 10 10 10 5 5 True False Username: 0 0 1 1 True False Password: 0 1 1 1 True True â— True gtk-dialog-authentication 1 1 1 1 True True â— True 1 0 1 1 False True 1 False True 1 login_ok login_cancel True 5 False True center dialog False False vertical False end gtk-apply False True True True False True False True 0 gtk-cancel False True True True False True False True 1 False True end 0 True False True False vertical True False 10 10 Shared WiFi connection information False True 0 True False 10 10 10 True True â— 1 0 1 1 True True minimum 8 characters â— True gtk-dialog-authentication 1 1 1 1 True False SSID: 0 0 1 1 True False Passphrase: 0 1 1 1 True True 1 True False 1 tethering_ok tethering_cancel connman-ui-0_20150622+dfsg.orig/lib/0000755000175000017500000000000012541725135015323 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/lib/service.c0000644000175000017500000012441612541725135017137 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #define CONNMAN_SERVICE_INTERFACE CONNMAN_DBUS_NAME ".Service" #define PROPERTY(n) Service_updatable_properties[n] enum connman_service_property { SERVICE_STATE = 0, SERVICE_ERROR = 1, SERVICE_STRENGTH = 2, SERVICE_FAVORITE = 3, SERVICE_AUTOCONNECT = 4, SERVICE_ROAMING = 5, SERVICE_NAMESERVERS = 6, SERVICE_NAMESERVERS_CONFIGURATION = 7, SERVICE_TIMESERVERS = 8, SERVICE_TIMESERVERS_CONFIGURATION = 9, SERVICE_DOMAINS = 10, SERVICE_DOMAINS_CONFIGURATION = 11, SERVICE_IPv4 = 12, SERVICE_IPv4_CONFIGURATION = 13, SERVICE_IPv6 = 14, SERVICE_IPv6_CONFIGURATION = 15, SERVICE_PROXY = 16, SERVICE_PROXY_CONFIGURATION = 17, SERVICE_PROVIDER = 18, SERVICE_ETHERNET = 19, SERVICE_MAX = 20, }; static const char *Service_updatable_properties[] = { "State", "Error", "Strength", "Favorite", "AutoConnect", "Roaming", "Nameservers", "Nameservers.Configuration", "Timeservers", "Timeservers.Configuration", "Domains", "Domains.Configuration", "IPv4", "IPv4.Configuration", "IPv6", "IPv6.Configuration", "Proxy", "Proxy.Configuration", "Provider", "Ethernet", }; struct connman_service { char *path; enum connman_state state; char *error; char *name; char *type; char *security; uint8_t strength; gboolean favorite; gboolean immutable; gboolean autoconnect; gboolean roaming; char *nameservers; char *nameservers_conf; char *timeservers; char *timeservers_conf; char *domains; char *domains_conf; struct connman_ipv4 *ipv4; struct connman_ipv4 *ipv4_conf; struct connman_ipv6 *ipv6; struct connman_ipv6 *ipv6_conf; struct connman_proxy *proxy; struct connman_proxy *proxy_conf; struct connman_provider *provider; struct connman_ethernet *ethernet; int update_index; guint property_changed_wid; guint to_update[SERVICE_MAX]; connman_property_changed_cb_f property_changed_cb; void *property_changed_user_data; DBusPendingCall *call_modify[SERVICE_MAX]; guint to_error[SERVICE_MAX]; connman_property_set_cb_f property_set_error_cb; void *property_set_error_user_data; }; struct connman_service_interface { DBusConnection *dbus_cnx; gboolean refreshed; GHashTable *services; GSList *ordered_services; connman_path_changed_cb_f removed_cb; connman_refresh_cb_f refresh_services_cb; connman_scan_cb_f scan_services_cb; guint to_refresh; void *refresh_user_data; struct connman_service *selected_service; }; static struct connman_service_interface *service_if = NULL; static void ipv4_free(gpointer data) { struct connman_ipv4 *ipv4 = data; if (ipv4 == NULL) return; g_free(ipv4->method); g_free(ipv4->address); g_free(ipv4->netmask); g_free(ipv4->gateway); g_free(ipv4); } static void ipv6_free(gpointer data) { struct connman_ipv6 *ipv6 = data; if (ipv6 == NULL) return; g_free(ipv6->method); g_free(ipv6->address); g_free(ipv6->gateway); g_free(ipv6->privacy); g_free(ipv6); } static void proxy_free(gpointer data) { struct connman_proxy *proxy = data; if (proxy == NULL) return; g_free(proxy->method); g_free(proxy->url); g_free(proxy->servers); g_free(proxy->excludes); g_free(proxy); } static void provider_free(gpointer data) { struct connman_provider *provider = data; if (provider == NULL) return; g_free(provider->host); g_free(provider->domain); g_free(provider->name); g_free(provider->type); g_free(provider); } static void ethernet_free(gpointer data) { struct connman_ethernet *ethernet = data; if (ethernet == NULL) return; g_free(ethernet->method); g_free(ethernet->interface); g_free(ethernet->address); g_free(ethernet->duplex); g_free(ethernet); } static void service_free(gpointer data) { struct connman_service *service = data; int i; if (service_if != NULL && service_if->selected_service == service) return; if (service->property_changed_wid != 0) g_dbus_remove_watch(service_if->dbus_cnx, service->property_changed_wid); for (i = 0; i < SERVICE_MAX; i++) { if (service->to_update[i] != 0) g_source_remove(service->to_update[i]); if (service->call_modify[i] != 0) { dbus_pending_call_cancel(service->call_modify[i]); dbus_pending_call_unref(service->call_modify[i]); } if (service->to_error[i] != 0) g_source_remove(service->to_error[i]); } g_free(service->path); g_free(service->error); g_free(service->name); g_free(service->type); g_free(service->security); g_free(service->nameservers); g_free(service->nameservers_conf); g_free(service->timeservers); g_free(service->timeservers_conf); g_free(service->domains); g_free(service->domains_conf); ipv4_free(service->ipv4); ipv4_free(service->ipv4_conf); ipv6_free(service->ipv6); ipv6_free(service->ipv6_conf); proxy_free(service->proxy); proxy_free(service->proxy_conf); provider_free(service->provider); ethernet_free(service->ethernet); g_free(service); } static struct connman_service *get_service(const char *path) { struct connman_service *service; if (path == NULL || service_if == NULL) return NULL; service = g_hash_table_lookup(service_if->services, path); if (service == NULL && service_if->selected_service != NULL) { if (g_strcmp0(path, service_if->selected_service->path) == 0) service = service_if->selected_service; } return service; } static void destroy_property(gpointer user_data) { struct property_change *property = user_data; struct connman_service *service; if (property == NULL) return; service = get_service(property->path); if (service != NULL) { if (property->error != 0) service->to_error[property->index] = 0; else service->to_update[property->index] = 0; } g_free(property); } static gboolean property_changed_or_error(gpointer user_data) { struct property_change *property = user_data; struct connman_service *service; service = get_service(property->path); if (service == NULL) return FALSE; if (property->error != 0) { if (service->property_set_error_cb == NULL) return FALSE; service->property_set_error_cb(property->path, property->name, property->error, service->property_set_error_user_data); return FALSE; } if (service->property_changed_cb != NULL) { service->property_changed_cb(property->path, property->name, service->property_changed_user_data); } return FALSE; } static void property_update(struct connman_service *service, int index) { struct property_change *property; if (service->property_changed_cb == NULL) return; property = g_try_malloc0(sizeof(struct property_change)); if (property == NULL) return; property->index = index; property->name = PROPERTY(index); property->path = service->path; if (service->to_update[index] != 0) g_source_remove(service->to_update[index]); service->to_update[index] = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, property_changed_or_error, property, destroy_property); } static struct connman_ipv4 *parse_ipv4(DBusMessageIter *arg, struct connman_ipv4 *ipv4) { DBusMessageIter dict; gboolean set = FALSE; char *value; if (ipv4 == NULL) { ipv4 = g_try_malloc0(sizeof(struct connman_ipv4)); if (ipv4 == NULL) return NULL; } dbus_message_iter_recurse(arg, &dict); if (cui_dbus_get_dict_entry_basic(&dict, "Method", DBUS_TYPE_STRING, &value) == 0) { g_free(ipv4->method); ipv4->method = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Address", DBUS_TYPE_STRING, &value) == 0) { g_free(ipv4->address); ipv4->address = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Netmask", DBUS_TYPE_STRING, &value) == 0) { g_free(ipv4->netmask); ipv4->netmask = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Gateway", DBUS_TYPE_STRING, &value) == 0) { g_free(ipv4->gateway); ipv4->gateway = g_strdup(value); set = TRUE; } if (set == TRUE) return ipv4; g_free(ipv4); return NULL; } static struct connman_ipv6 *parse_ipv6(DBusMessageIter *arg, struct connman_ipv6 *ipv6) { uint16_t uint16_value; DBusMessageIter dict; gboolean set = FALSE; char *value; if (ipv6 == NULL) { ipv6 = g_try_malloc0(sizeof(struct connman_ipv6)); if (ipv6 == NULL) return NULL; } dbus_message_iter_recurse(arg, &dict); if (cui_dbus_get_dict_entry_basic(&dict, "Method", DBUS_TYPE_STRING, &value) == 0) { g_free(ipv6->method); ipv6->method = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Address", DBUS_TYPE_STRING, &value) == 0) { g_free(ipv6->address); ipv6->address = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Prefix", DBUS_TYPE_UINT16, &uint16_value) == 0) { ipv6->prefix = uint16_value; set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Gateway", DBUS_TYPE_STRING, &value) == 0) { g_free(ipv6->gateway); ipv6->gateway = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Privacy", DBUS_TYPE_STRING, &value) == 0) { g_free(ipv6->privacy); ipv6->privacy = g_strdup(value); set = TRUE; } if (set == TRUE) return ipv6; g_free(ipv6); return NULL; } static struct connman_proxy *parse_proxy(DBusMessageIter *arg, struct connman_proxy *proxy) { DBusMessageIter dict; gboolean set = FALSE; char *value, **array; int length; if (proxy == NULL) { proxy = g_try_malloc0(sizeof(struct connman_proxy)); if (proxy == NULL) return NULL; } dbus_message_iter_recurse(arg, &dict); if (cui_dbus_get_dict_entry_basic(&dict, "Method", DBUS_TYPE_STRING, &value) == 0) { g_free(proxy->method); proxy->method = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "URL", DBUS_TYPE_STRING, &value) == 0) { g_free(proxy->url); proxy->url = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_array(&dict, "Servers", DBUS_TYPE_STRING, &length, &array) == 0) { g_free(proxy->servers); if (array != NULL) { proxy->servers = g_strjoinv(";", array); g_free(array); } else proxy->servers = NULL; set = TRUE; } if (cui_dbus_get_dict_entry_array(&dict, "Excludes", DBUS_TYPE_STRING, &length, &array) == 0) { g_free(proxy->excludes); if (array != NULL) { proxy->excludes = g_strjoinv(";", array); g_free(array); } else proxy->excludes = NULL; set = TRUE; } if (set == TRUE) return proxy; g_free(proxy); return NULL; } static struct connman_provider *parse_provider(DBusMessageIter *arg, struct connman_provider *provider) { DBusMessageIter dict; gboolean set = FALSE; char *value; if (provider == NULL) { provider = g_try_malloc0(sizeof(struct connman_provider)); if (provider == NULL) return NULL; } dbus_message_iter_recurse(arg, &dict); if (cui_dbus_get_dict_entry_basic(&dict, "Host", DBUS_TYPE_STRING, &value) == 0) { g_free(provider->host); provider->host = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Domain", DBUS_TYPE_STRING, &value) == 0) { g_free(provider->domain); provider->domain = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Name", DBUS_TYPE_STRING, &value) == 0) { g_free(provider->name); provider->name = g_strdup(value); set = TRUE; } if (cui_dbus_get_dict_entry_basic(&dict, "Type", DBUS_TYPE_STRING, &value) == 0) { g_free(provider->type); provider->type = g_strdup(value); set = TRUE; } if (set == TRUE) return provider; g_free(provider); return NULL; } static struct connman_ethernet *parse_ethernet(DBusMessageIter *arg, struct connman_ethernet *ethernet) { uint16_t uint16_value; DBusMessageIter dict; char *value; if (ethernet == NULL) { ethernet = g_try_malloc0(sizeof(struct connman_ethernet)); if (ethernet == NULL) return NULL; }; dbus_message_iter_recurse(arg, &dict); if (cui_dbus_get_dict_entry_basic(&dict, "Method", DBUS_TYPE_STRING, &value) == 0) { g_free(ethernet->method); ethernet->method = g_strdup(value); } if (cui_dbus_get_dict_entry_basic(&dict, "Interface", DBUS_TYPE_STRING, &value) == 0) { g_free(ethernet->interface); ethernet->interface = g_strdup(value); } if (cui_dbus_get_dict_entry_basic(&dict, "Address", DBUS_TYPE_STRING, &value) == 0) { g_free(ethernet->address); ethernet->address = g_strdup(value); } if (cui_dbus_get_dict_entry_basic(&dict, "MTU", DBUS_TYPE_UINT16, &uint16_value) == 0) ethernet->mtu = uint16_value; if (cui_dbus_get_dict_entry_basic(&dict, "Speed", DBUS_TYPE_UINT16, &uint16_value) == 0) ethernet->speed = uint16_value; if (cui_dbus_get_dict_entry_basic(&dict, "Duplex", DBUS_TYPE_STRING, &value) == 0) { g_free(ethernet->duplex); ethernet->duplex = g_strdup(value); } return ethernet; } static bool update_service_property(DBusMessageIter *arg, void *user_data) { struct connman_service *service = user_data; const char *name, *value; gboolean boolean_value; char **array; int length; if (cui_dbus_get_basic(arg, DBUS_TYPE_STRING, &name) != 0) return FALSE; dbus_message_iter_next(arg); if (g_strcmp0(name, "Name") == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value); service->name = g_strdup(value); } else if (g_strcmp0(name, "Type") == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value); service->type = g_strdup(value); } else if (g_strcmp0(name, "Security") == 0) { cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array); g_free(service->security); if (array != NULL) { service->security = g_strjoinv(";", array); g_free(array); } else service->security = NULL; } else if (g_strcmp0(name, "Immutable") == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_BOOLEAN, &boolean_value); service->immutable = boolean_value; } else if (g_strcmp0(name, PROPERTY(SERVICE_STATE)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value); service->state = string2enum_state(value); service->update_index = SERVICE_STATE; } else if (g_strcmp0(name, PROPERTY(SERVICE_ERROR)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value); g_free(service->error); service->error = g_strdup(value); service->update_index = SERVICE_ERROR; } else if (g_strcmp0(name, PROPERTY(SERVICE_STRENGTH)) == 0) { uint8_t uint8_value; cui_dbus_get_basic_variant(arg, DBUS_TYPE_BYTE, &uint8_value); service->strength = uint8_value; service->update_index = SERVICE_STRENGTH; } else if (g_strcmp0(name, PROPERTY(SERVICE_FAVORITE)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_BOOLEAN, &boolean_value); service->favorite = boolean_value; service->update_index = SERVICE_FAVORITE; } else if (g_strcmp0(name, PROPERTY(SERVICE_AUTOCONNECT)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_BOOLEAN, &boolean_value); service->autoconnect = boolean_value; service->update_index = SERVICE_AUTOCONNECT; } else if (g_strcmp0(name, PROPERTY(SERVICE_ROAMING)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_BOOLEAN, &boolean_value); service->roaming = boolean_value; service->update_index = SERVICE_ROAMING; } else if (g_strcmp0(name, PROPERTY(SERVICE_NAMESERVERS)) == 0) { cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array); g_free(service->nameservers); if (array != NULL) { service->nameservers = g_strjoinv(";", array); g_free(array); } else service->nameservers = NULL; service->update_index = SERVICE_NAMESERVERS; } else if (g_strcmp0(name, PROPERTY(SERVICE_NAMESERVERS_CONFIGURATION)) == 0) { cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array); g_free(service->nameservers_conf); if (array != NULL) { service->nameservers_conf = g_strjoinv(";", array); g_free(array); } else service->nameservers_conf = NULL; service->update_index = SERVICE_NAMESERVERS_CONFIGURATION; } else if (g_strcmp0(name, PROPERTY(SERVICE_DOMAINS)) == 0) { cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array); g_free(service->domains); if (array != NULL) { service->domains = g_strjoinv(";", array); g_free(array); } else service->domains = NULL; service->update_index = SERVICE_DOMAINS; } else if (g_strcmp0(name, PROPERTY(SERVICE_DOMAINS_CONFIGURATION)) == 0) { cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array); g_free(service->domains_conf); if (array != NULL) { service->domains_conf = g_strjoinv(";", array); g_free(array); } else service->domains_conf = NULL; service->update_index = SERVICE_DOMAINS_CONFIGURATION; } else if (g_strcmp0(name, PROPERTY(SERVICE_TIMESERVERS)) == 0) { cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array); g_free(service->timeservers); if (array != NULL) { service->timeservers = g_strjoinv(";", array); g_free(array); } else service->timeservers = NULL; service->update_index = SERVICE_TIMESERVERS; } else if (g_strcmp0(name, PROPERTY(SERVICE_TIMESERVERS_CONFIGURATION)) == 0) { cui_dbus_get_array(arg, DBUS_TYPE_STRING, &length, &array); g_free(service->timeservers_conf); if (array != NULL) { service->timeservers_conf = g_strjoinv(";", array); g_free(array); } else service->timeservers_conf = NULL; service->update_index = SERVICE_TIMESERVERS_CONFIGURATION; } else if (g_strcmp0(name, PROPERTY(SERVICE_IPv4)) == 0) { service->ipv4 = parse_ipv4(arg, service->ipv4); service->update_index = SERVICE_IPv4; } else if (g_strcmp0(name, PROPERTY(SERVICE_IPv4_CONFIGURATION)) == 0) { service->ipv4_conf = parse_ipv4(arg, service->ipv4_conf); service->update_index = SERVICE_IPv4_CONFIGURATION; } else if (g_strcmp0(name, PROPERTY(SERVICE_IPv6)) == 0) { service->ipv6 = parse_ipv6(arg, service->ipv6); service->update_index = SERVICE_IPv6; } else if (g_strcmp0(name, PROPERTY(SERVICE_IPv6_CONFIGURATION)) == 0) { service->ipv6_conf = parse_ipv6(arg, service->ipv6_conf); service->update_index = SERVICE_IPv6_CONFIGURATION; } else if (g_strcmp0(name, PROPERTY(SERVICE_PROXY)) == 0) { service->proxy = parse_proxy(arg, service->proxy); service->update_index = SERVICE_PROXY; } else if (g_strcmp0(name, PROPERTY(SERVICE_PROXY_CONFIGURATION)) == 0) { service->proxy_conf = parse_proxy(arg, service->proxy_conf); service->update_index = SERVICE_PROXY_CONFIGURATION; } else if (g_strcmp0(name, PROPERTY(SERVICE_PROVIDER)) == 0) { service->provider = parse_provider(arg, service->provider); service->update_index = SERVICE_PROVIDER; } else if (g_strcmp0(name, PROPERTY(SERVICE_ETHERNET)) == 0) { service->ethernet = parse_ethernet(arg, service->ethernet); service->update_index = SERVICE_ETHERNET; } return FALSE; } static gboolean property_changed_signal_cb(DBusConnection *dbus_cnx, DBusMessage *message, void *user_data) { struct connman_service *service = user_data; DBusMessageIter arg; if (message == NULL) return TRUE; if (dbus_message_iter_init(message, &arg) == FALSE) return TRUE; service->update_index = SERVICE_MAX; update_service_property(&arg, service); if (service->update_index < SERVICE_MAX) property_update(service, service->update_index); return TRUE; } static void update_or_create_service(const char *obj_path, DBusMessageIter *dict) { struct connman_service *service; if (service_if == NULL) return; service = get_service(obj_path); if (service == NULL) { service = g_try_malloc0(sizeof(struct connman_service)); if (service == NULL) return; service->path = g_strdup(obj_path); g_hash_table_insert(service_if->services, service->path, service); service->property_changed_wid = g_dbus_add_signal_watch( service_if->dbus_cnx, CONNMAN_DBUS_NAME, service->path, CONNMAN_SERVICE_INTERFACE, "PropertyChanged", property_changed_signal_cb, service, NULL); } service_if->ordered_services = g_slist_append( service_if->ordered_services, service->path); cui_dbus_foreach_dict_entry(dict, update_service_property, service); } gboolean refresh_cb(gpointer data) { if (service_if == NULL || service_if->refresh_services_cb == NULL) return FALSE; service_if->refresh_services_cb(service_if->refresh_user_data); return FALSE; } static void call_refresh_callback(void) { if (service_if == NULL || service_if->refresh_services_cb == NULL) return; if (service_if->to_refresh != 0) g_source_remove(service_if->to_refresh); service_if->to_refresh = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, refresh_cb, NULL, NULL); } static void service_changed_signal_cb(DBusMessageIter *iter) { DBusMessageIter array, strt; char *obj_path; int arg_type; if (service_if == NULL) return; g_slist_free(service_if->ordered_services); service_if->ordered_services = NULL; dbus_message_iter_recurse(iter, &array); arg_type = dbus_message_iter_get_arg_type(&array); while (arg_type != DBUS_TYPE_INVALID) { dbus_message_iter_recurse(&array, &strt); cui_dbus_get_basic(&strt, DBUS_TYPE_OBJECT_PATH, &obj_path); dbus_message_iter_next(&strt); update_or_create_service(obj_path, &strt); dbus_message_iter_next(&array); arg_type = dbus_message_iter_get_arg_type(&array); } dbus_message_iter_next(iter); dbus_message_iter_recurse(iter, &array); arg_type = dbus_message_iter_get_arg_type(&array); while (arg_type != DBUS_TYPE_INVALID) { struct connman_service *service; cui_dbus_get_basic(&array, DBUS_TYPE_OBJECT_PATH, &obj_path); service = get_service(obj_path); if (service != NULL) { g_hash_table_remove(service_if->services, obj_path); if (service_if->removed_cb != NULL) service_if->removed_cb(obj_path); } dbus_message_iter_next(&array); arg_type = dbus_message_iter_get_arg_type(&array); } if (service_if->refreshed == TRUE) call_refresh_callback(); } static void get_services_cb(DBusMessageIter *iter) { DBusMessageIter array; DBusMessageIter strt; char *obj_path; int arg_type; if (iter == NULL || service_if == NULL) return; g_slist_free(service_if->ordered_services); service_if->ordered_services = NULL; if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY) return; dbus_message_iter_recurse(iter, &array); arg_type = dbus_message_iter_get_arg_type(&array); while (arg_type != DBUS_TYPE_INVALID) { dbus_message_iter_recurse(&array, &strt); cui_dbus_get_basic(&strt, DBUS_TYPE_OBJECT_PATH, &obj_path); dbus_message_iter_next(&strt); update_or_create_service(obj_path, &strt); dbus_message_iter_next(&array); arg_type = dbus_message_iter_get_arg_type(&array); } if (service_if->refreshed == FALSE) { service_if->refreshed = TRUE; __connman_manager_get_services(get_services_cb); } else call_refresh_callback(); } static void scan_services_cb(void *user_data) { if (service_if == NULL) return; if (service_if->scan_services_cb != NULL) service_if->scan_services_cb(service_if->refresh_user_data); } static int call_empty_method(const char *path, const char *method) { struct connman_service *service; DBusMessage *message; service = get_service(path); if (service == NULL) return -EINVAL; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, service->path, CONNMAN_SERVICE_INTERFACE, method); if (message == NULL) return -ENOMEM; if (g_dbus_send_message(service_if->dbus_cnx, message) == FALSE) { dbus_message_unref(message); return -EINVAL; } return 0; } static void set_property_cb(DBusPendingCall *pending, void *user_data) { struct property_setting *set = user_data; struct connman_service *service; struct property_change *property; DBusMessage *reply; DBusError error; if (dbus_pending_call_get_completed(pending) == FALSE) return; if (set == NULL) return; service = set->data; service->call_modify[set->index] = NULL; if (service->property_set_error_cb == NULL) return; property = g_try_malloc0(sizeof(struct property_change)); if (property == NULL) return; reply = dbus_pending_call_steal_reply(pending); if (reply == NULL) return; dbus_error_init(&error); if (dbus_set_error_from_message(&error, reply) == FALSE) goto done; printf("SetProperty Error: %s\n", error.message); dbus_error_free(&error); if (service->property_set_error_cb == NULL) goto done; property = g_try_malloc0(sizeof(struct property_change)); if (property == NULL) goto done; property->path = service->path; property->name = PROPERTY(set->index); property->error = -1; if (service->to_error[set->index] != 0) g_source_remove(service->to_error[set->index]); service->to_error[set->index] = g_timeout_add_full( G_PRIORITY_DEFAULT, 0, property_changed_or_error, property, destroy_property); done: dbus_message_unref(reply); } static void append_ipv4_config(DBusMessageIter *dict, void *data) { const struct connman_ipv4 *ipv4 = data; cui_dbus_append_dict_entry_basic(dict, "Method", DBUS_TYPE_STRING, (void *) &ipv4->method); cui_dbus_append_dict_entry_basic(dict, "Address", DBUS_TYPE_STRING, (void *) &ipv4->address); cui_dbus_append_dict_entry_basic(dict, "Netmask", DBUS_TYPE_STRING, (void *) &ipv4->netmask); cui_dbus_append_dict_entry_basic(dict, "Gateway", DBUS_TYPE_STRING, (void *) &ipv4->gateway); } static void append_ipv6_config(DBusMessageIter *dict, void *data) { const struct connman_ipv6 *ipv6 = data; cui_dbus_append_dict_entry_basic(dict, "Method", DBUS_TYPE_STRING, (void *) &ipv6->method); cui_dbus_append_dict_entry_basic(dict, "Address", DBUS_TYPE_STRING, (void *) &ipv6->address); cui_dbus_append_dict_entry_basic(dict, "PrefixLength", DBUS_TYPE_BYTE, (void *) &ipv6->prefix); cui_dbus_append_dict_entry_basic(dict, "Gateway", DBUS_TYPE_STRING, (void *) &ipv6->gateway); cui_dbus_append_dict_entry_basic(dict, "Privacy", DBUS_TYPE_STRING, (void *) &ipv6->privacy); } static void append_string_list(DBusMessageIter *iter, void *data) { const char **string_list = data; for (; *string_list != NULL; string_list++) cui_dbus_append_basic(iter, NULL, DBUS_TYPE_STRING, string_list); } static void append_proxy_config(DBusMessageIter *dict, void *data) { const struct connman_proxy *proxy = data; char **config_list; cui_dbus_append_dict_entry_basic(dict, "Method", DBUS_TYPE_STRING, (void *) &proxy->method); cui_dbus_append_dict_entry_basic(dict, "URL", DBUS_TYPE_STRING, (void *) &proxy->url); config_list = g_strsplit(proxy->servers, ";", 0); cui_dbus_append_dict_entry_array(dict, "Servers", DBUS_TYPE_STRING, append_string_list, (void *)config_list); g_strfreev(config_list); config_list = g_strsplit(proxy->excludes, ";", 0); cui_dbus_append_dict_entry_array(dict, "Excludes", DBUS_TYPE_STRING, append_string_list, (void *)config_list); g_strfreev(config_list); } static int set_service_property(struct connman_service *service, enum connman_service_property property, int dbus_type, void *data) { struct property_setting *set = NULL; const char *property_name; DBusMessage *message; DBusMessageIter arg; if (connman == NULL) return -EINVAL; if (service->call_modify[property] != NULL) return -EINVAL; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, service->path, CONNMAN_SERVICE_INTERFACE, "SetProperty"); if (message == NULL) return -ENOMEM; set = g_try_malloc0(sizeof(struct property_setting)); if (set == NULL) goto error; set->data = service; set->index = property; property_name = PROPERTY(property); dbus_message_iter_init_append(message, &arg); switch (property) { case SERVICE_IPv4_CONFIGURATION: cui_dbus_append_dict(&arg, property_name, append_ipv4_config, data); break; case SERVICE_IPv6_CONFIGURATION: cui_dbus_append_dict(&arg, property_name, append_ipv6_config, data); break; case SERVICE_PROXY_CONFIGURATION: cui_dbus_append_dict(&arg, property_name, append_proxy_config, data); break; case SERVICE_NAMESERVERS_CONFIGURATION: case SERVICE_DOMAINS_CONFIGURATION: case SERVICE_TIMESERVERS_CONFIGURATION: cui_dbus_append_array(&arg, property_name, DBUS_TYPE_STRING, append_string_list, data); break; default: cui_dbus_append_basic(&arg, property_name, dbus_type, data); break; } if (dbus_connection_send_with_reply(service_if->dbus_cnx, message, &service->call_modify[property], DBUS_TIMEOUT_USE_DEFAULT) == FALSE) goto error; if (dbus_pending_call_set_notify(service->call_modify[property], set_property_cb, set, g_free) == FALSE) goto error; return 0; error: dbus_message_unref(message); if (set == NULL) return -ENOMEM; g_free(set); return -EINVAL; } int connman_service_init(void) { if (connman == NULL) return -EINVAL; if (service_if != NULL) return 0; service_if = g_try_malloc0(sizeof(struct connman_service_interface)); if (service_if == NULL) return -ENOMEM; service_if->services = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, service_free); if (service_if->services == NULL) { g_free(service_if); return -ENOMEM; }; service_if->dbus_cnx = dbus_connection_ref(connman->dbus_cnx); return 0; } void connman_service_finalize(void) { if (service_if == NULL) return; __connman_manager_register_service_signal(NULL); dbus_connection_unref(service_if->dbus_cnx); connman_service_deselect(); g_slist_free(service_if->ordered_services); g_hash_table_destroy(service_if->services); g_free(service_if); service_if = NULL; } int connman_service_refresh_services_list(connman_refresh_cb_f refresh_cb, connman_scan_cb_f scan_cb, void *user_data) { GList *techs; GList *list; char *path; if (service_if == NULL) return -EINVAL; service_if->refreshed = FALSE; techs = connman_technology_get_technologies(); if (techs == NULL) return -EINVAL; for (list = techs; list != NULL; list = list->next) { const char *type; path = list->data; type = connman_technology_get_type(path); if (g_strcmp0(type, "wifi") == 0) break; path = NULL; }; g_list_free(techs); service_if->refresh_services_cb = refresh_cb; service_if->scan_services_cb = scan_cb; service_if->refresh_user_data = user_data; if (path == NULL || connman_technology_is_enabled(path) == FALSE) { __connman_manager_get_services(get_services_cb); if (service_if->scan_services_cb != NULL) service_if->scan_services_cb( service_if->refresh_user_data); } else { __connman_manager_register_service_signal( service_changed_signal_cb); connman_technology_scan(path, scan_services_cb, NULL); __connman_manager_get_services(get_services_cb); } return 0; } GSList *connman_service_get_services(void) { if (service_if == NULL || service_if->ordered_services == NULL) return NULL; return g_slist_copy(service_if->ordered_services); } void connman_service_free_services_list(void) { if (service_if == NULL) return; __connman_manager_register_service_signal(NULL); g_slist_free(service_if->ordered_services); service_if->ordered_services = NULL; g_hash_table_remove_all(service_if->services); } void connman_service_set_property_changed_callback(const char *path, connman_property_changed_cb_f property_changed_cb, void *user_data) { struct connman_service *service; service = get_service(path); if (service == NULL) return; service->property_changed_cb = property_changed_cb; service->property_changed_user_data = user_data; } void connman_service_set_property_error_callback(const char *path, connman_property_set_cb_f property_set_cb, void *user_data) { struct connman_service *service; service = get_service(path); if (service == NULL) return; service->property_set_error_cb = property_set_cb; service->property_set_error_user_data = user_data; } void connman_service_set_removed_callback( connman_path_changed_cb_f removed_cb) { if (service_if != NULL) service_if->removed_cb = removed_cb; } const char *connman_service_get_name(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->name; } const char *connman_service_get_type(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->type; } enum connman_state connman_service_get_state(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return CONNMAN_STATE_OFFLINE; return service->state; } const char *connman_service_get_error(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->error; } const char *connman_service_get_security(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->security; } uint8_t connman_service_get_strength(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return 0; return service->strength; } gboolean connman_service_is_favorite(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return FALSE; return service->favorite; } gboolean connman_service_is_immutable(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return FALSE; return service->immutable; } gboolean connman_service_is_autoconnect(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return FALSE; return service->autoconnect; } gboolean connman_service_is_roaming(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return FALSE; return service->roaming; } const char *connman_service_get_nameservers(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->nameservers; } const char *connman_service_get_nameservers_config(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->nameservers_conf; } const char *connman_service_get_domains(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->domains; } const char *connman_service_get_domains_config(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->domains_conf; } const char *connman_service_get_timeservers(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->timeservers; } const char *connman_service_get_timeservers_config(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->timeservers_conf; } const struct connman_ipv4 *connman_service_get_ipv4(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->ipv4; } const struct connman_ipv4 *connman_service_get_ipv4_config(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->ipv4_conf; } const struct connman_ipv6 *connman_service_get_ipv6(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->ipv6; } const struct connman_ipv6 *connman_service_get_ipv6_config(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->ipv6_conf; } const struct connman_proxy *connman_service_get_proxy(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->proxy; } const struct connman_proxy *connman_service_get_proxy_config(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->proxy_conf; } const struct connman_provider *connman_service_get_provider(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->provider; } const struct connman_ethernet *connman_service_get_ethernet(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return NULL; return service->ethernet; } gboolean connman_service_is_connected(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return FALSE; if (service->state == CONNMAN_STATE_READY || service->state == CONNMAN_STATE_ONLINE) return TRUE; return FALSE; } int connman_service_select(const char *path) { struct connman_service *service; service = get_service(path); if (service == NULL) return -EINVAL; service_if->selected_service = service; return 0; } void connman_service_deselect(void) { struct connman_service *service, *service_in_ht; if (service_if == NULL || service_if->selected_service == NULL) return; service = service_if->selected_service; service_if->selected_service = NULL; service_in_ht = get_service(service->path); if (service_in_ht == NULL) service_free(service); } int connman_service_connect(const char *path) { return call_empty_method(path, "Connect"); } int connman_service_disconnect(const char *path) { return call_empty_method(path, "Disconnect"); } int connman_service_remove(const char *path) { return call_empty_method(path, "Remove"); } int connman_service_set_autoconnectable(const char *path, gboolean enable) { struct connman_service *service; service = get_service(path); if (service == NULL) return -EINVAL; return set_service_property(service, SERVICE_AUTOCONNECT, DBUS_TYPE_BOOLEAN, &enable); } int connman_service_set_ipv4_config(const char *path, const struct connman_ipv4 *ipv4_config) { struct connman_service *service; if (ipv4_config == NULL) return -EINVAL; service = get_service(path); if (service == NULL) return -EINVAL; if (service->ipv4_conf != NULL) { struct connman_ipv4 *orig = service->ipv4_conf; if (g_strcmp0(orig->method, ipv4_config->method) != 0 || g_strcmp0(orig->address, ipv4_config->address) != 0 || g_strcmp0(orig->netmask, ipv4_config->netmask) != 0 || g_strcmp0(orig->gateway, ipv4_config->gateway) != 0) goto set; else return 0; } set: return set_service_property(service, SERVICE_IPv4_CONFIGURATION, 0, (void *)ipv4_config); } int connman_service_set_ipv6_config(const char *path, const struct connman_ipv6 *ipv6_config) { struct connman_service *service; if (ipv6_config == NULL) return -EINVAL; service = get_service(path); if (service == NULL) return -EINVAL; if (service->ipv6_conf != NULL) { struct connman_ipv6 *orig = service->ipv6_conf; if (g_strcmp0(orig->method, ipv6_config->method) != 0 || g_strcmp0(orig->address, ipv6_config->address) != 0 || g_strcmp0(orig->gateway, ipv6_config->gateway) != 0 || g_strcmp0(orig->privacy, ipv6_config->privacy) != 0 || orig->prefix != ipv6_config->prefix) goto set; else return 0; } set: return set_service_property(service, SERVICE_IPv6_CONFIGURATION, 0, (void *)ipv6_config); } int connman_service_set_proxy_config(const char *path, const struct connman_proxy *proxy_config) { struct connman_service *service; if (proxy_config == NULL) return -EINVAL; service = get_service(path); if (service == NULL) return -EINVAL; if (service->proxy_conf != NULL) { struct connman_proxy *orig = service->proxy_conf; if (g_strcmp0(orig->method, proxy_config->method) != 0 || g_strcmp0(orig->url, proxy_config->url) != 0 || g_strcmp0(orig->servers, proxy_config->servers) != 0 || g_strcmp0(orig->excludes, proxy_config->excludes) != 0) goto set; else return 0; } set: return set_service_property(service, SERVICE_PROXY_CONFIGURATION, 0, (void *)proxy_config); } int connman_service_set_nameservers_config(const char *path, const char *nameservers_config) { struct connman_service *service; char **config_list; int ret; service = get_service(path); if (service == NULL) return -EINVAL; if (g_strcmp0(service->nameservers_conf, nameservers_config) == 0) return 0; config_list = g_strsplit(nameservers_config, ";", 0); if (config_list == NULL) return -ENOMEM; ret = set_service_property(service, SERVICE_NAMESERVERS_CONFIGURATION, DBUS_TYPE_STRING, (void *)config_list); g_strfreev(config_list); return ret; } int connman_service_set_domains_config(const char *path, const char *domains_config) { struct connman_service *service; char **config_list; int ret; service = get_service(path); if (service == NULL) return -EINVAL; if (g_strcmp0(service->domains_conf, domains_config) == 0) return 0; config_list = g_strsplit(domains_config, ";", 0); if (config_list == NULL) return -ENOMEM; ret = set_service_property(service, SERVICE_DOMAINS_CONFIGURATION, DBUS_TYPE_STRING, (void *)config_list); g_strfreev(config_list); return ret; } int connman_service_set_timeservers_config(const char *path, const char *timeservers_config) { struct connman_service *service; char **config_list; int ret; service = get_service(path); if (service == NULL) return -EINVAL; if (g_strcmp0(service->timeservers_conf, timeservers_config) == 0) return 0; config_list = g_strsplit(timeservers_config, ";", 0); if (config_list == NULL) return -ENOMEM; ret = set_service_property(service, SERVICE_TIMESERVERS_CONFIGURATION, DBUS_TYPE_STRING, (void *)config_list); g_strfreev(config_list); return ret; } connman-ui-0_20150622+dfsg.orig/lib/agent.c0000644000175000017500000002651212541725135016573 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include #define CONNMAN_AGENT_INTERFACE CONNMAN_DBUS_NAME ".Agent" #define CONNMAN_AGENT_PATH "/net/connman/agent/connmanui" struct connman_agent { DBusConnection *dbus_cnx; DBusMessage *pending_reply; agent_error_cb_f error_cb; agent_browser_cb_f browser_cb; agent_input_cb_f input_cb; agent_cancel_cb_f cancel_cb; }; static struct connman_agent *agent_if; static DBusMessage *agent_release_method(DBusConnection *dbus_cnx, DBusMessage *msg, void *data) { if (agent_if == NULL) goto reply; g_dbus_unregister_interface(agent_if->dbus_cnx, CONNMAN_AGENT_PATH, CONNMAN_AGENT_INTERFACE); if (agent_if->pending_reply != NULL) dbus_message_unref(agent_if->pending_reply); dbus_connection_unref(agent_if->dbus_cnx); g_free(agent_if); agent_if = NULL; reply: return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } static DBusMessage *agent_report_error_method(DBusConnection *dbus_cnx, DBusMessage *msg, void *data) { DBusMessageIter arg; const char *error; const char *path; if (agent_if == NULL || agent_if->error_cb == NULL) goto error; if (dbus_message_iter_init(msg, &arg) == FALSE) goto error; if (cui_dbus_get_basic(&arg, DBUS_TYPE_OBJECT_PATH, &path) != 0) goto error; dbus_message_iter_next(&arg); if (cui_dbus_get_basic(&arg, DBUS_TYPE_STRING, &error) != 0) goto error; agent_if->pending_reply = dbus_message_ref(msg); agent_if->error_cb(path, error); return NULL; error: return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } static DBusMessage *agent_request_browser_method(DBusConnection *dbus_cnx, DBusMessage *msg, void *data) { DBusMessageIter arg; const char *path; const char *url; if (agent_if == NULL || agent_if->browser_cb == NULL) goto error; if (dbus_message_iter_init(msg, &arg) == FALSE) goto error; if (cui_dbus_get_basic(&arg, DBUS_TYPE_OBJECT_PATH, &path) != 0) goto error; dbus_message_iter_next(&arg); if (cui_dbus_get_basic(&arg, DBUS_TYPE_STRING, &url) != 0) goto error; agent_if->pending_reply = dbus_message_ref(msg); agent_if->browser_cb(path, url); return NULL; error: return g_dbus_create_error(msg, CONNMAN_ERROR ".Canceled", NULL); } struct agent_input_data { gboolean hidden; gboolean identity; gboolean passphrase; gboolean wpspin; gboolean login; const char *previous_passphrase; const char *previous_wpspin; }; static bool parse_input_request(DBusMessageIter *arg, void *user_data) { struct agent_input_data *data = user_data; const char *name; if (cui_dbus_get_basic(arg, DBUS_TYPE_STRING, &name) != 0) return FALSE; dbus_message_iter_next(arg); if (g_strcmp0(name, "Passphrase") == 0) data->passphrase = TRUE; else if (g_strcmp0(name, "WPS") == 0) data->wpspin = TRUE; else if (g_strcmp0(name, "Name") == 0) data->hidden = TRUE; else if (g_strcmp0(name, "Identity") == 0) data->identity = TRUE; else if (g_strcmp0(name, "Username") == 0) data->login = TRUE; else if (g_strcmp0(name, "PreviousPassphrase") == 0) { DBusMessageIter dict; const char **value; const char *type; dbus_message_iter_recurse(arg, &dict); cui_dbus_get_dict_entry_basic(&dict, "Type", DBUS_TYPE_STRING, &type); if (g_strcmp0(type, "psk") == 0) value = &data->previous_passphrase; else if (g_strcmp0(type, "wpspin") == 0) value = &data->previous_wpspin; cui_dbus_get_dict_entry_basic(&dict, "Value", DBUS_TYPE_STRING, &value); } return FALSE; } static DBusMessage *agent_request_input_method(DBusConnection *dbus_cnx, DBusMessage *msg, void *data) { struct agent_input_data arg_data; DBusMessageIter arg; const char *path; if (agent_if == NULL || agent_if->input_cb == NULL) goto error; memset(&arg_data, 0, sizeof(struct agent_input_data)); if (dbus_message_iter_init(msg, &arg) == FALSE) goto error; if (cui_dbus_get_basic(&arg, DBUS_TYPE_OBJECT_PATH, &path) != 0) goto error; dbus_message_iter_next(&arg); cui_dbus_foreach_dict_entry(&arg, parse_input_request, &arg_data); if (arg_data.hidden == FALSE && arg_data.identity == FALSE && arg_data.passphrase == FALSE && arg_data.login == FALSE) goto error; agent_if->pending_reply = dbus_message_ref(msg); agent_if->input_cb(path, arg_data.hidden, arg_data.identity, arg_data.passphrase, arg_data.previous_passphrase, arg_data.wpspin, arg_data.previous_wpspin, arg_data.login); return NULL; error: return g_dbus_create_error(msg, CONNMAN_ERROR ".Canceled", NULL); } static DBusMessage *agent_cancel_method(DBusConnection *dbus_cnx, DBusMessage *msg, void *data) { if (agent_if == NULL) goto reply; if (agent_if->pending_reply != NULL) { dbus_message_unref(agent_if->pending_reply); agent_if->pending_reply = NULL; } if (agent_if->cancel_cb != NULL) agent_if->cancel_cb(); reply: return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } static GDBusMethodTable agent_methods[] = { { GDBUS_METHOD("Release", NULL, NULL, agent_release_method) }, { GDBUS_ASYNC_METHOD("ReportError", GDBUS_ARGS({"service", "o"}, {"error", "s"}), NULL, agent_report_error_method) }, { GDBUS_ASYNC_METHOD("RequestBrowser", GDBUS_ARGS({"service", "o"}, {"url", "s"}), NULL, agent_request_browser_method) }, { GDBUS_ASYNC_METHOD("RequestInput", GDBUS_ARGS({"service", "o"}, {"fields", "a{sv}"}), GDBUS_ARGS({"inputs", "a{sv}"}), agent_request_input_method) }, { GDBUS_METHOD("Cancel", NULL, NULL, agent_cancel_method) }, { NULL }, }; static inline void send_agent_reply(DBusMessage *reply) { if (reply == NULL) goto error; g_dbus_send_message(agent_if->dbus_cnx, reply); error: dbus_message_unref(agent_if->pending_reply); agent_if->pending_reply = NULL; } static void agent_reply_error(const char *error, const char *msg) { DBusMessage *reply; if (agent_if == NULL || agent_if->pending_reply == NULL) return; reply = g_dbus_create_error(agent_if->pending_reply, error, "%s", msg); send_agent_reply(reply); } int connman_agent_init(void) { if (connman == NULL) return -EINVAL; if (agent_if != NULL) return 0; agent_if = g_try_malloc0(sizeof(struct connman_agent)); if (agent_if == NULL) return -ENOMEM; agent_if->dbus_cnx = dbus_connection_ref(connman->dbus_cnx); g_dbus_register_interface(agent_if->dbus_cnx, CONNMAN_AGENT_PATH, CONNMAN_AGENT_INTERFACE, agent_methods, NULL, NULL, NULL, NULL); connman_manager_register_agent(CONNMAN_AGENT_PATH); return 0; } void connman_agent_finalize(void) { if (agent_if == NULL) return; connman_manager_unregister_agent(CONNMAN_AGENT_PATH); g_dbus_unregister_interface(agent_if->dbus_cnx, CONNMAN_AGENT_PATH, CONNMAN_AGENT_INTERFACE); if (agent_if->pending_reply != NULL) dbus_message_unref(agent_if->pending_reply); dbus_connection_unref(agent_if->dbus_cnx); g_free(agent_if); agent_if = NULL; } int connman_agent_set_error_cb(agent_error_cb_f error_cb) { if (agent_if == NULL) return -EINVAL; agent_if->error_cb = error_cb; return 0; } int connman_agent_set_browser_cb(agent_browser_cb_f browser_cb) { if (agent_if == NULL) return -EINVAL; agent_if->browser_cb = browser_cb; return 0; } int connman_agent_set_input_cb(agent_input_cb_f input_cb) { if (agent_if == NULL) return -EINVAL; agent_if->input_cb = input_cb; return 0; } int connman_agent_set_cancel_cb(agent_cancel_cb_f cancel_cb) { if (agent_if == NULL) return -EINVAL; agent_if->cancel_cb = cancel_cb; return 0; } void connman_agent_reply_retry(void) { agent_reply_error(CONNMAN_AGENT_INTERFACE ".Error.Retry", "Retry"); } void connman_agent_reply_canceled(void) { agent_reply_error(CONNMAN_AGENT_INTERFACE ".Error.Canceled", "Canceled"); } void connman_agent_reply_launch_browser(void) { agent_reply_error(CONNMAN_AGENT_INTERFACE ".Error.LaunchBrowser", "Launch the Browser"); } int connman_agent_reply_identity(const char *identity, const char *passphrase) { DBusMessageIter arg, dict; DBusMessage *reply; if (agent_if == NULL || agent_if->pending_reply == NULL) return 0; if (identity == NULL || passphrase == NULL) return -EINVAL; reply = dbus_message_new_method_return(agent_if->pending_reply); if (reply == NULL) return -ENOMEM; dbus_message_iter_init_append(reply, &arg); if (cui_dbus_open_dict(&arg, &dict) == FALSE) goto error; cui_dbus_append_dict_entry_basic(&dict, "Identity", DBUS_TYPE_STRING, &identity); cui_dbus_append_dict_entry_basic(&dict, "Passphrase", DBUS_TYPE_STRING, &passphrase); dbus_message_iter_close_container(&dict, &arg); send_agent_reply(reply); return 0; error: dbus_message_unref(reply); dbus_message_unref(agent_if->pending_reply); agent_if->pending_reply = NULL; return -ENOMEM; } int connman_agent_reply_passphrase(const char *hidden_name, const char *passphrase, gboolean wps, const char *wpspin) { DBusMessageIter arg, dict; DBusMessage *reply; if (agent_if == NULL || agent_if->pending_reply == NULL) return 0; if (passphrase == NULL && hidden_name == NULL && wps == FALSE) return -EINVAL; reply = dbus_message_new_method_return(agent_if->pending_reply); if (reply == NULL) return -ENOMEM; dbus_message_iter_init_append(reply, &arg); if (cui_dbus_open_dict(&arg, &dict) == FALSE) goto error; if (hidden_name != NULL) cui_dbus_append_dict_entry_basic(&dict, "Name", DBUS_TYPE_STRING, &hidden_name); if (passphrase != NULL) cui_dbus_append_dict_entry_basic(&dict, "Passphrase", DBUS_TYPE_STRING, &passphrase); else if (wps == TRUE) { if (wpspin == NULL) wpspin = ""; cui_dbus_append_dict_entry_basic(&dict, "WPS", DBUS_TYPE_STRING, &wpspin); } dbus_message_iter_close_container(&arg, &dict); send_agent_reply(reply); return 0; error: dbus_message_unref(reply); dbus_message_unref(agent_if->pending_reply); agent_if->pending_reply = NULL; return -ENOMEM; } int connman_agent_reply_login(const char *username, const char *password) { DBusMessageIter arg, dict; DBusMessage *reply; if (agent_if == NULL || agent_if->pending_reply == NULL) return 0; if (username == NULL && password == NULL) return -EINVAL; reply = dbus_message_new_method_return(agent_if->pending_reply); if (reply == NULL) return -ENOMEM; dbus_message_iter_init_append(reply, &arg); if (cui_dbus_open_dict(&arg, &dict) == FALSE) goto error; cui_dbus_append_dict_entry_basic(&dict, "Username", DBUS_TYPE_STRING, &username); cui_dbus_append_dict_entry_basic(&dict, "Password", DBUS_TYPE_STRING, &password); dbus_message_iter_close_container(&dict, &arg); send_agent_reply(reply); return 0; error: dbus_message_unref(reply); dbus_message_unref(agent_if->pending_reply); agent_if->pending_reply = NULL; return -ENOMEM; } connman-ui-0_20150622+dfsg.orig/lib/cui-dbus.h0000644000175000017500000001570612541725135017220 0ustar nicknick/* * cui library * * Copyright (C) 2011-2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 2.1, * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef __CUI_DBUS_H__ #define __CUI_DBUS_H__ #include #include #ifndef DBUS_TIMEOUT_USE_DEFAULT #define DBUS_TIMEOUT_USE_DEFAULT (-1) #endif /* * Used for cui_dbus_append_dict_entry_dict, * and cui_dbus_get_dict_entry. * It should not be used anywhere else. */ enum cui_dbus_entry { CUI_DBUS_ENTRY_BASIC = 0, CUI_DBUS_ENTRY_ARRAY = 1, CUI_DBUS_ENTRY_FIXED_ARRAY = 2, CUI_DBUS_ENTRY_DICT = 3, }; typedef void (*cui_dbus_property_f) (DBusMessageIter *iter, void *user_data); typedef bool (*cui_dbus_foreach_callback_f) (DBusMessageIter *iter, void *user_data); static inline bool cui_dbus_open_dict(DBusMessageIter *iter, DBusMessageIter *dict) { return dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, dict); } void cui_dbus_append_dict(DBusMessageIter *iter, const char *key_name, cui_dbus_property_f property_function, void *user_data); void cui_dbus_append_basic(DBusMessageIter *iter, const char *key_name, int dbus_type, void *value); void cui_dbus_append_array(DBusMessageIter *iter, const char *key_name, int dbus_type, cui_dbus_property_f property_function, void *user_data); void cui_dbus_append_fixed_array(DBusMessageIter *iter, const char *key_name, int dbus_type, int length, void *value); /* Use preferably the inline functions below this one */ void cui_dbus_append_dict_entry(DBusMessageIter *dict, const char *key_name, enum cui_dbus_entry entry_type, int dbus_type, int length, cui_dbus_property_f property_function, void *user_data); static inline void cui_dbus_append_dict_entry_basic(DBusMessageIter *dict, const char *key_name, int dbus_type, void *value) { cui_dbus_append_dict_entry(dict, key_name, CUI_DBUS_ENTRY_BASIC, dbus_type, 0, NULL, value); } static inline void cui_dbus_append_dict_entry_array(DBusMessageIter *dict, const char *key_name, int dbus_type, cui_dbus_property_f property_function, void *user_data) { cui_dbus_append_dict_entry(dict, key_name, CUI_DBUS_ENTRY_ARRAY, dbus_type, 0, property_function, user_data); } static inline void cui_dbus_append_dict_entry_fixed_array(DBusMessageIter *dict, const char *key_name, int dbus_type, int length, void *value) { cui_dbus_append_dict_entry(dict, key_name, CUI_DBUS_ENTRY_FIXED_ARRAY, dbus_type, length, NULL, value); } static inline void cui_dbus_append_dict_entry_dict(DBusMessageIter *dict, const char *key_name, cui_dbus_property_f property_function, void *user_data) { cui_dbus_append_dict_entry(dict, key_name, CUI_DBUS_ENTRY_DICT, 0, 0, property_function, user_data); } int cui_dbus_get_basic(DBusMessageIter *iter, int dbus_type, void *destination); int cui_dbus_get_basic_variant(DBusMessageIter *iter, int dbus_type, void *destination); int cui_dbus_get_array(DBusMessageIter *iter, int dbus_type, int *length, void *destination); int cui_dbus_get_fixed_array(DBusMessageIter *iter, int *length, void *destination); int cui_dbus_foreach_dict_entry(DBusMessageIter *iter, cui_dbus_foreach_callback_f callback, void *user_data); /* Use preferably the inline functions below this one */ int cui_dbus_get_dict_entry(DBusMessageIter *iter, const char *key_name, enum cui_dbus_entry entry_type, int dbus_type, int *length, void *destination); static inline int cui_dbus_get_dict_entry_basic(DBusMessageIter *iter, const char *key_name, int dbus_type, void *destination) { return cui_dbus_get_dict_entry(iter, key_name, CUI_DBUS_ENTRY_BASIC, dbus_type, NULL, destination); } static inline int cui_dbus_get_dict_entry_array(DBusMessageIter *iter, const char *key_name, int dbus_type, int *length, void *destination) { return cui_dbus_get_dict_entry(iter, key_name, CUI_DBUS_ENTRY_ARRAY, dbus_type, length, destination); } static inline int cui_dbus_get_dict_entry_fixed_array(DBusMessageIter *iter, const char *key_name, int dbus_type, int *length, void *destination) { return cui_dbus_get_dict_entry(iter, key_name, CUI_DBUS_ENTRY_FIXED_ARRAY, dbus_type, length, destination); } static inline int cui_dbus_get_dict_entry_dict(DBusMessageIter *iter, const char *key_name, DBusMessageIter *dict) { return cui_dbus_get_dict_entry(iter, key_name, CUI_DBUS_ENTRY_DICT, DBUS_TYPE_INVALID, NULL, dict); } /* Use preferably the inline functions below this one */ int cui_dbus_get_struct_entry(DBusMessageIter *iter, unsigned int position, enum cui_dbus_entry entry_type, int dbus_type, int *length, void *destination); static inline int cui_dbus_get_struct_entry_basic(DBusMessageIter *iter, unsigned int position, int dbus_type, void *destination) { return cui_dbus_get_struct_entry(iter, position, CUI_DBUS_ENTRY_BASIC, dbus_type, NULL, destination); } static inline int cui_dbus_get_struct_entry_array(DBusMessageIter *iter, unsigned int position, int dbus_type, int *length, void *destination) { return cui_dbus_get_struct_entry(iter, position, CUI_DBUS_ENTRY_ARRAY, dbus_type, length, destination); } static inline int cui_dbus_get_struct_entry_fixed_array(DBusMessageIter *iter, unsigned int position, int dbus_type, int *length, void *destination) { return cui_dbus_get_struct_entry(iter, position, CUI_DBUS_ENTRY_FIXED_ARRAY, dbus_type, length, destination); } static inline int cui_dbus_get_struct_entry_dict(DBusMessageIter *iter, unsigned int position, DBusMessageIter *dict) { return cui_dbus_get_struct_entry(iter, position, CUI_DBUS_ENTRY_DICT, DBUS_TYPE_INVALID, NULL, dict); } static inline dbus_bool_t cui_dbus_is_service_running(DBusConnection *dbus_cnx, const char *dbus_service_name) { if (dbus_bus_name_has_owner(dbus_cnx, dbus_service_name, NULL) == FALSE) return FALSE; return TRUE; } #endif /* __CUI_DBUS_H__ */ connman-ui-0_20150622+dfsg.orig/lib/manager.c0000644000175000017500000003767212541725135017120 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #define CONNMAN_MANAGER_PATH "/" #define CONNMAN_MANAGER_INTERFACE CONNMAN_DBUS_NAME ".Manager" #define PROPERTY(n) Manager_updatable_properties[n] enum connman_manage_property { MANAGER_STATE = 0, MANAGER_OFFLINEMODE = 1, MANAGER_MAX = 2, }; static const char *Manager_updatable_properties[] = { "State", "OfflineMode", }; struct connman_manager { DBusConnection *dbus_cnx; DBusPendingCall *get_properties_call; guint property_changed_wid; connman_property_changed_cb_f property_changed_cb; void *property_user_data; enum connman_state state; gboolean offlinemode; guint source[MANAGER_MAX]; /* Technology part */ DBusPendingCall *get_technologies_call; guint technology_added_wid; guint technology_removed_wid; connman_manager_get_technologies_cb_f get_technologies_cb; connman_manager_technology_added_cb_f technology_added_cb; connman_manager_technology_removed_cb_f technology_removed_cb; /* Service part */ DBusPendingCall *get_services_call; guint services_changed_wid; connman_manager_get_services_cb_f get_services_cb; connman_manager_service_changed_cb services_changed_cb; }; static struct connman_manager *manager = NULL; static void destroy_property(gpointer user_data) { struct property_change *property = user_data; if (property == NULL) return; if (manager != NULL) manager->source[property->index] = 0; g_free(property); } static gboolean property_changed(gpointer user_data) { struct property_change *property = user_data; if (manager == NULL || manager->property_changed_cb == NULL) return FALSE; manager->property_changed_cb(property->path, property->name, manager->property_user_data); return FALSE; } enum connman_state string2enum_state(const char *state) { if (g_strcmp0(state, "offline") == 0) return CONNMAN_STATE_OFFLINE; else if (g_strcmp0(state, "idle") == 0) return CONNMAN_STATE_IDLE; else if (g_strcmp0(state, "ready") == 0) return CONNMAN_STATE_READY; else if (g_strcmp0(state, "online") == 0) return CONNMAN_STATE_ONLINE; else if (g_strcmp0(state, "failure") == 0) return CONNMAN_STATE_FAILURE; return CONNMAN_STATE_OFFLINE; } static void update_manager_property(int index) { struct property_change *property; property = g_try_malloc0(sizeof(struct property_change)); if (property == NULL) return; if (manager->source[index] != 0) g_source_remove(manager->source[index]); property->index = index; property->name = PROPERTY(index); manager->source[index] = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, property_changed, property, destroy_property); } static void get_properties_callback(DBusPendingCall *pending, void *user_data) { dbus_bool_t offlinemode; DBusMessageIter arg; DBusMessage *reply; const char *state; if (dbus_pending_call_get_completed(pending) == FALSE) return; manager->get_properties_call = NULL; reply = dbus_pending_call_steal_reply(pending); if (reply == NULL) goto error; if (dbus_message_iter_init(reply, &arg) == FALSE) goto error; if (cui_dbus_get_dict_entry_basic(&arg, PROPERTY(MANAGER_STATE), DBUS_TYPE_STRING, &state) == 0) { manager->state = string2enum_state(state); update_manager_property(MANAGER_STATE); } if (cui_dbus_get_dict_entry_basic(&arg, PROPERTY(MANAGER_OFFLINEMODE), DBUS_TYPE_BOOLEAN, &offlinemode) == 0) { manager->offlinemode = offlinemode; update_manager_property(MANAGER_OFFLINEMODE); } error: if (reply != NULL) dbus_message_unref(reply); dbus_pending_call_unref(pending); } static gboolean property_changed_signal_cb(DBusConnection *dbus_cnx, DBusMessage *message, void *user_data) { DBusMessageIter arg; const char *name; if (message == NULL) return TRUE; if (dbus_message_iter_init(message, &arg) == FALSE) return TRUE; if (cui_dbus_get_basic(&arg, DBUS_TYPE_STRING, &name) != 0) return TRUE; dbus_message_iter_next(&arg); if (g_strcmp0(name, PROPERTY(MANAGER_STATE)) == 0) { const char *state; if (cui_dbus_get_basic_variant(&arg, DBUS_TYPE_STRING, &state) == 0) { manager->state = string2enum_state(state); update_manager_property(MANAGER_STATE); } } else if (g_strcmp0(name, PROPERTY(MANAGER_OFFLINEMODE)) == 0) { dbus_bool_t offlinemode; if (cui_dbus_get_basic_variant(&arg, DBUS_TYPE_BOOLEAN, &offlinemode) == 0) { manager->offlinemode = offlinemode; update_manager_property(MANAGER_OFFLINEMODE); } } return TRUE; } static void get_technologies_callback(DBusPendingCall *pending, void *user_data) { connman_manager_get_technologies_cb_f callback; DBusMessageIter arg; DBusMessage *reply; if (dbus_pending_call_get_completed(pending) == FALSE) return; manager->get_technologies_call = NULL; callback = manager->get_technologies_cb; manager->get_technologies_cb = NULL; reply = dbus_pending_call_steal_reply(pending); if (reply == NULL) goto error; if (dbus_message_iter_init(reply, &arg) == FALSE) goto error; if (callback != NULL) callback(&arg); error: if (reply != NULL) dbus_message_unref(reply); dbus_pending_call_unref(pending); } static gboolean technology_added_signal_cb(DBusConnection *dbus_cnx, DBusMessage *message, void *user_data) { DBusMessageIter arg; if (message == NULL) return TRUE; if (dbus_message_iter_init(message, &arg) == FALSE) return TRUE; if (manager->technology_added_cb != NULL) manager->technology_added_cb(&arg); return TRUE; } static gboolean technology_removed_signal_cb(DBusConnection *dbus_cnx, DBusMessage *message, void *user_data) { DBusMessageIter arg; if (message == NULL) return TRUE; if (dbus_message_iter_init(message, &arg) == FALSE) return TRUE; if (manager->technology_removed_cb != NULL) manager->technology_removed_cb(&arg); return TRUE; } static void get_services_callback(DBusPendingCall *pending, void *user_data) { connman_manager_get_services_cb_f callback; DBusMessageIter arg; DBusMessage *reply; if (dbus_pending_call_get_completed(pending) == FALSE) return; manager->get_services_call = NULL; callback = manager->get_services_cb; manager->get_services_cb = NULL; reply = dbus_pending_call_steal_reply(pending); if (reply == NULL) goto error; if (dbus_message_iter_init(reply, &arg) == FALSE) goto error; if (callback != NULL) callback(&arg); error: if (reply != NULL) dbus_message_unref(reply); dbus_pending_call_unref(pending); } static gboolean services_changed_signal_cb(DBusConnection *dbus_cnx, DBusMessage *message, void *user_data) { DBusMessageIter arg; if (message == NULL) return TRUE; if (dbus_message_iter_init(message, &arg) == FALSE) return TRUE; if (manager->services_changed_cb != NULL) manager->services_changed_cb(&arg); return TRUE; } int __connman_manager_get_technologies(connman_manager_get_technologies_cb_f cb) { DBusMessage *message; if (manager == NULL) return -EINVAL; if (manager->get_technologies_call != NULL) { dbus_pending_call_cancel(manager->get_technologies_call); dbus_pending_call_unref(manager->get_technologies_call); manager->get_technologies_call = NULL; } manager->get_technologies_cb = NULL; if (cb == NULL) return 0; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "GetTechnologies"); if (message == NULL) return -ENOMEM; manager->get_technologies_cb = cb; if (dbus_connection_send_with_reply(manager->dbus_cnx, message, &manager->get_technologies_call, DBUS_TIMEOUT_USE_DEFAULT) == FALSE) goto error; if (dbus_pending_call_set_notify(manager->get_technologies_call, get_technologies_callback, NULL, NULL) == FALSE) goto error; dbus_message_unref(message); return 0; error: dbus_message_unref(message); return -EINVAL; } int __connman_manager_register_technology_signals(connman_manager_technology_added_cb_f added_cb, connman_manager_technology_removed_cb_f removed_cb) { if (manager == NULL) return -EINVAL; manager->technology_added_cb = NULL; manager->technology_removed_cb = NULL; if (manager->technology_added_wid != 0) g_dbus_remove_watch(manager->dbus_cnx, manager->technology_added_wid); if (manager->technology_removed_wid != 0) g_dbus_remove_watch(manager->dbus_cnx, manager->technology_removed_wid); manager->technology_added_wid = 0; manager->technology_removed_wid = 0; if (added_cb == NULL && removed_cb == NULL) return 0; manager->technology_added_wid = g_dbus_add_signal_watch( manager->dbus_cnx, CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "TechnologyAdded", technology_added_signal_cb, NULL, NULL); if (manager->technology_added_wid == 0) goto error; manager->technology_removed_wid = g_dbus_add_signal_watch( manager->dbus_cnx, CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "TechnologyRemoved", technology_removed_signal_cb, NULL, NULL); if (manager->technology_removed_wid == 0) goto error; manager->technology_added_cb = added_cb; manager->technology_removed_cb = removed_cb; return 0; error: if (manager->technology_added_wid != 0) { g_dbus_remove_watch(manager->dbus_cnx, manager->technology_added_wid); manager->technology_added_wid = 0; } return -EINVAL; } int __connman_manager_get_services(connman_manager_get_services_cb_f cb) { DBusMessage *message; if (manager == NULL) return -EINVAL; manager->get_services_cb = NULL; if (manager->get_services_call != NULL) { dbus_pending_call_cancel(manager->get_services_call); dbus_pending_call_unref(manager->get_services_call); manager->get_services_call = NULL; } if (cb == NULL) return 0; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "GetServices"); if (message == NULL) return -ENOMEM; manager->get_services_cb = cb; if (dbus_connection_send_with_reply(manager->dbus_cnx, message, &manager->get_services_call, DBUS_TIMEOUT_USE_DEFAULT) == FALSE) goto error; if (dbus_pending_call_set_notify(manager->get_services_call, get_services_callback, NULL, NULL) == FALSE) goto error; dbus_message_unref(message); return 0; error: dbus_message_unref(message); return -EINVAL; } int __connman_manager_register_service_signal(connman_manager_service_changed_cb cb) { if (manager == NULL) return -EINVAL; manager->services_changed_cb = NULL; if (manager->services_changed_wid != 0) g_dbus_remove_watch(manager->dbus_cnx, manager->services_changed_wid); manager->services_changed_wid = 0; if (cb == NULL) return 0; manager->services_changed_wid = g_dbus_add_signal_watch( manager->dbus_cnx, CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "ServicesChanged", services_changed_signal_cb, NULL, NULL); if (manager->services_changed_wid == 0) return -EINVAL; manager->services_changed_cb = cb; return 0; } int connman_manager_init(connman_property_changed_cb_f property_changed_cb, void *user_data) { DBusMessage *message = NULL; int err = -EINVAL; if (connman == NULL) return -EINVAL; if (manager != NULL) return 0; manager = g_try_malloc0(sizeof(struct connman_manager)); if (manager == NULL) return -ENOMEM; manager->dbus_cnx = dbus_connection_ref(connman->dbus_cnx); manager->property_changed_cb = property_changed_cb; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "GetProperties"); if (message == NULL) { err = -ENOMEM; goto error; } if (dbus_connection_send_with_reply(manager->dbus_cnx, message, &manager->get_properties_call, DBUS_TIMEOUT_USE_DEFAULT) == FALSE) goto error; if (dbus_pending_call_set_notify(manager->get_properties_call, get_properties_callback, NULL, NULL) == FALSE) goto error; manager->property_changed_wid = g_dbus_add_signal_watch( manager->dbus_cnx, CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "PropertyChanged", property_changed_signal_cb, NULL, NULL); if (manager->property_changed_wid == 0) goto error; manager->property_user_data = user_data; dbus_message_unref(message); return 0; error: if (message != NULL) dbus_message_unref(message); connman_manager_finalize(); return err; } void connman_manager_finalize(void) { int i; if (manager == NULL) return; manager->property_changed_cb = NULL; for (i = 0; i < MANAGER_MAX; i++) { if (manager->source[i] != 0) g_source_remove(manager->source[i]); } if (manager->get_properties_call != NULL) { dbus_pending_call_cancel(manager->get_properties_call); dbus_pending_call_unref(manager->get_properties_call); } if (manager->property_changed_wid != 0) g_dbus_remove_watch(manager->dbus_cnx, manager->property_changed_wid); if (manager->get_technologies_call != NULL) { dbus_pending_call_cancel(manager->get_technologies_call); dbus_pending_call_unref(manager->get_technologies_call); } if (manager->technology_added_wid != 0) g_dbus_remove_watch(manager->dbus_cnx, manager->technology_added_wid); if (manager->technology_removed_wid != 0) g_dbus_remove_watch(manager->dbus_cnx, manager->technology_removed_wid); if (manager->get_services_call != NULL) { dbus_pending_call_cancel(manager->get_services_call); dbus_pending_call_unref(manager->get_services_call); } dbus_connection_unref(manager->dbus_cnx); g_free(manager); manager = NULL; } int connman_manager_set_offlinemode(gboolean offlinemode) { DBusMessage *message; DBusMessageIter arg; if (manager == NULL) return -EINVAL; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "SetProperty"); if (message == NULL) return -ENOMEM; dbus_message_iter_init_append(message, &arg); cui_dbus_append_basic(&arg, PROPERTY(MANAGER_OFFLINEMODE), DBUS_TYPE_BOOLEAN, &offlinemode); if (g_dbus_send_message(manager->dbus_cnx, message) == FALSE) return -EINVAL; return 0; } enum connman_state connman_manager_get_state(void) { if (manager == NULL) return CONNMAN_STATE_UNKNOWN; return manager->state; } gboolean connman_manager_get_offlinemode(void) { if (manager == NULL) return TRUE; return manager->offlinemode; } void connman_manager_register_agent(const char *path) { DBusMessage *message; DBusMessageIter arg; if (manager == NULL) return; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "RegisterAgent"); if (message == NULL) return; dbus_message_iter_init_append(message, &arg); cui_dbus_append_basic(&arg, NULL, DBUS_TYPE_OBJECT_PATH, &path); g_dbus_send_message(manager->dbus_cnx, message); } void connman_manager_unregister_agent(const char *path) { DBusMessage *message; DBusMessageIter arg; if (manager == NULL) return; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE, "UnregisterAgent"); if (message == NULL) return; dbus_message_iter_init_append(message, &arg); cui_dbus_append_basic(&arg, NULL, DBUS_TYPE_OBJECT_PATH, &path); g_dbus_send_message(manager->dbus_cnx, message); } connman-ui-0_20150622+dfsg.orig/lib/connman-interface.h0000644000175000017500000002116012541725135021063 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef __CONNMAN_INTERFACE_H__ #define __CONNMAN_INTERFACE_H__ #include #include #include #include // TEMPORARY #include // enum connman_state { CONNMAN_STATE_UNKNOWN = 0, CONNMAN_STATE_OFFLINE = 1, CONNMAN_STATE_IDLE = 2, CONNMAN_STATE_READY = 3, CONNMAN_STATE_ONLINE = 4, CONNMAN_STATE_FAILURE = 5, }; struct connman_ipv4 { char *method; char *address; char *netmask; char *gateway; }; struct connman_ipv6 { char *method; char *address; uint8_t prefix; char *gateway; char *privacy; }; struct connman_proxy { char *method; char *url; char *servers; char *excludes; }; struct connman_provider { char *host; char *domain; char *name; char *type; }; struct connman_ethernet { char *method; char *interface; char *address; uint16_t mtu; uint16_t speed; char *duplex; }; typedef void (*connman_interface_cb_f)(void *user_data); typedef void (*connman_scan_cb_f)(void *user_data); typedef void (*connman_refresh_cb_f)(void *user_data); typedef void (*connman_property_changed_cb_f)(const char *path, const char *property, void *user_data); typedef void (*connman_property_set_cb_f)(const char *path, const char *property, int error, void *user_data); typedef void (*connman_path_changed_cb_f)(const char *path); typedef void (*agent_error_cb_f)(const char *path, const char *error); typedef void (*agent_browser_cb_f)(const char *path, const char *url); typedef void (*agent_input_cb_f)(const char *path, gboolean hidden, gboolean identity, gboolean passphrase, const char *previous_passphrase, gboolean wpspin, const char *previous_wpspin, gboolean login); typedef void (*agent_cancel_cb_f)(void); /***********\ * Main part * \***********/ int connman_interface_init(connman_interface_cb_f interface_connected_cb, connman_interface_cb_f interface_disconnected_cb, void *user_data); void connman_interface_finalize(void); /**************\ * Manager part * \**************/ int connman_manager_init(connman_property_changed_cb_f property_changed_cb, void *user_data); void connman_manager_finalize(void); int connman_manager_set_offlinemode(gboolean offlinemode); enum connman_state connman_manager_get_state(void); gboolean connman_manager_get_offlinemode(void); void connman_manager_register_agent(const char *path); void connman_manager_unregister_agent(const char *path); /*****************\ * Technology part * \*****************/ int connman_technology_init(void); void connman_technology_finalize(void); void connman_technology_set_global_property_callback( connman_property_changed_cb_f property_changed_cb, void *user_data); void connman_technology_set_property_changed_callback(const char *path, connman_property_changed_cb_f property_changed_cb, void *user_data); void connman_technology_set_property_error_callback(const char *path, connman_property_set_cb_f property_set_cb, void *user_data); void connman_technology_set_removed_callback( connman_path_changed_cb_f removed_cb); void connman_technology_set_added_callback(connman_path_changed_cb_f added_cb); GList *connman_technology_get_technologies(void); int connman_technology_scan(const char *path, connman_scan_cb_f callback, void *user_data); int connman_technology_enable(const char *path, gboolean enable); int connman_technology_tether(const char *path, gboolean tethering); int connman_technology_set_tethering_identifier(const char *path, const char *identifier); int connman_technology_set_tethering_passphrase(const char *path, const char *passphrase); const char *connman_technology_get_name(const char *path); const char *connman_technology_get_type(const char *path); gboolean connman_technology_is_enabled(const char *path); gboolean connman_technology_is_tethering(const char *path); const char *connman_technology_get_tethering_identifier(const char *path); const char *connman_technology_get_tethering_passphrase(const char *path); /**************\ * Service part * \**************/ int connman_service_init(void); void connman_service_finalize(void); int connman_service_refresh_services_list(connman_refresh_cb_f refresh_cb, connman_scan_cb_f scan_cb, void *user_data); GSList *connman_service_get_services(void); void connman_service_free_services_list(void); void connman_service_set_property_changed_callback(const char *path, connman_property_changed_cb_f property_changed_cb, void *user_data); void connman_service_set_property_error_callback(const char *path, connman_property_set_cb_f property_set_cb, void *user_data); void connman_service_set_removed_callback( connman_path_changed_cb_f removed_cb); const char *connman_service_get_name(const char *path); const char *connman_service_get_type(const char *path); enum connman_state connman_service_get_state(const char *path); const char *connman_service_get_error(const char *path); const char *connman_service_get_security(const char *path); uint8_t connman_service_get_strength(const char *path); gboolean connman_service_is_favorite(const char *path); gboolean connman_service_is_immutable(const char *path); gboolean connman_service_is_autoconnect(const char *path); gboolean connman_service_is_roaming(const char *path); const char *connman_service_get_nameservers(const char *path); const char *connman_service_get_nameservers_config(const char *path); const char *connman_service_get_domains(const char *path); const char *connman_service_get_domains_config(const char *path); const char *connman_service_get_timeservers(const char *path); const char *connman_service_get_timeservers_config(const char *path); const struct connman_ipv4 *connman_service_get_ipv4(const char *path); const struct connman_ipv4 *connman_service_get_ipv4_config(const char *path); const struct connman_ipv6 *connman_service_get_ipv6(const char *path); const struct connman_ipv6 *connman_service_get_ipv6_config(const char *path); const struct connman_proxy *connman_service_get_proxy(const char *path); const struct connman_proxy *connman_service_get_proxy_config(const char *path); const struct connman_provider *connman_service_get_provider(const char *path); const struct connman_ethernet *connman_service_get_ethernet(const char *path); gboolean connman_service_is_connected(const char *path); int connman_service_select(const char *path); void connman_service_deselect(void); int connman_service_connect(const char *path); int connman_service_disconnect(const char *path); int connman_service_remove(const char *path); int connman_service_set_autoconnectable(const char *path, gboolean enable); int connman_service_set_ipv4_config(const char *path, const struct connman_ipv4 *ipv4_config); int connman_service_set_ipv6_config(const char *path, const struct connman_ipv6 *ipv6_config); int connman_service_set_proxy_config(const char *path, const struct connman_proxy *proxy_config); int connman_service_set_nameservers_config(const char *path, const char *nameservers_config); int connman_service_set_domains_config(const char *path, const char *domains_config); int connman_service_set_timeservers_config(const char *path, const char *timeservers_config); /************\ * Agent part * \************/ int connman_agent_init(void); void connman_agent_finalize(void); int connman_agent_set_error_cb(agent_error_cb_f error_cb); int connman_agent_set_browser_cb(agent_browser_cb_f browser_cb); int connman_agent_set_input_cb(agent_input_cb_f input_cb); int connman_agent_set_cancel_cb(agent_cancel_cb_f cancel_cb); void connman_agent_reply_retry(void); void connman_agent_reply_canceled(void); void connman_agent_reply_launch_browser(void); int connman_agent_reply_identity(const char *identity, const char *passphrase); int connman_agent_reply_passphrase(const char *hidden_name, const char *passphrase, gboolean wps, const char *wpspin); int connman_agent_reply_login(const char *username, const char *password); #endif /* __CONNMAN_INTERFACE_H__ */ connman-ui-0_20150622+dfsg.orig/lib/interface.c0000644000175000017500000000657512541725135017444 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include DBusConnection *dbus_cnx_session = NULL; struct connman_interface *connman = NULL; static void connman_watch_interface_connected(DBusConnection *dbus_cnx, void *user_data) { if (connman == NULL || connman->interface_connected_cb == NULL) return; connman->interface_connected_cb(connman->user_data); } static void connman_watch_interface_disconnected(DBusConnection *dbus_cnx, void *user_data) { if (connman == NULL || connman->interface_disconnected_cb == NULL) return; connman->interface_disconnected_cb(connman->user_data); } int connman_interface_init(connman_interface_cb_f interface_connected_cb, connman_interface_cb_f interface_disconnected_cb, void *user_data) { DBusConnection *dbus_cnx; DBusError error; if (connman != NULL) return 0; if (interface_connected_cb == NULL || interface_disconnected_cb == NULL) return -EINVAL; dbus_cnx = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, NULL); if (dbus_cnx == NULL) return -ENOMEM; dbus_cnx_session = g_dbus_setup_bus(DBUS_BUS_SESSION, NULL, NULL); if (dbus_cnx_session == NULL) { dbus_connection_unref(dbus_cnx); return -ENOMEM; } dbus_error_init(&error); if (g_dbus_request_name(dbus_cnx_session, "net.connman.ConnmanUI", &error) == FALSE) { if (dbus_error_is_set(&error) == TRUE) { printf("Error: %s\n", error.message); dbus_error_free(&error); } dbus_connection_unref(dbus_cnx); dbus_connection_unref(dbus_cnx_session); return -EALREADY; } connman = g_try_malloc0(sizeof(struct connman_interface)); if (connman == NULL) { dbus_connection_unref(dbus_cnx); dbus_connection_unref(dbus_cnx_session); return -ENOMEM; } connman->dbus_cnx = dbus_cnx; connman->interface_connected_cb = interface_connected_cb; connman->interface_disconnected_cb = interface_disconnected_cb; connman->interface_watch_id = g_dbus_add_service_watch(dbus_cnx, CONNMAN_DBUS_NAME, connman_watch_interface_connected, connman_watch_interface_disconnected, NULL, NULL); if (connman->interface_watch_id == 0) { dbus_connection_unref(dbus_cnx); dbus_connection_unref(dbus_cnx_session); g_free(connman); return -EINVAL; } /* We don't know yet if connman is present */ connman_watch_interface_disconnected(dbus_cnx, NULL); connman->user_data = user_data; return 0; } void connman_interface_finalize(void) { if (connman == NULL) return; g_dbus_remove_all_watches(connman->dbus_cnx); dbus_connection_unref(connman->dbus_cnx); if (dbus_cnx_session != NULL) dbus_connection_unref(dbus_cnx_session); dbus_cnx_session = NULL; g_free(connman); connman = NULL; } connman-ui-0_20150622+dfsg.orig/lib/utils.c0000644000175000017500000000144012541725135016626 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include connman-ui-0_20150622+dfsg.orig/lib/connman-private.h0000644000175000017500000000426312541725135020602 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #ifndef __CONNMAN_PRIVATE_H__ #define __CONNMAN_PRIVATE_H__ #include #define CONNMAN_DBUS_NAME "net.connman" #define CONNMAN_ERROR CONNMAN_DBUS_NAME ".Error" struct connman_interface { DBusConnection *dbus_cnx; guint interface_watch_id; connman_interface_cb_f interface_connected_cb; connman_interface_cb_f interface_disconnected_cb; void *user_data; }; struct property_change { int index; const char *path; const char *name; int error; }; struct property_setting { void *data; int index; }; extern struct connman_interface *connman; typedef void (*connman_manager_get_technologies_cb_f)(DBusMessageIter *iter); typedef void (*connman_manager_technology_added_cb_f)(DBusMessageIter *iter); typedef void (*connman_manager_technology_removed_cb_f)(DBusMessageIter *iter); typedef void (*connman_manager_get_services_cb_f)(DBusMessageIter *iter); typedef void (*connman_manager_service_changed_cb)(DBusMessageIter *iter); enum connman_state string2enum_state(const char *state); int __connman_manager_get_technologies(connman_manager_get_technologies_cb_f cb); int __connman_manager_register_technology_signals(connman_manager_technology_added_cb_f added_cb, connman_manager_technology_removed_cb_f removed_cb); int __connman_manager_get_services(connman_manager_get_services_cb_f cb); int __connman_manager_register_service_signal(connman_manager_service_changed_cb cb); #endif /* __CONNMAN_PRIVATE_H__ */ connman-ui-0_20150622+dfsg.orig/lib/technology.c0000644000175000017500000004516212541725135017652 0ustar nicknick/* * * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #define CONNMAN_TECHNOLOGY_INTERFACE CONNMAN_DBUS_NAME ".Technology" #define PROPERTY(n) Technology_updatable_properties[n] static void get_technologies_cb(DBusMessageIter *iter); enum connman_technology_property { TECHNOLOGY_POWERED = 0, TECHNOLOGY_CONNECTED = 1, TECHNOLOGY_TETHERING = 2, TECHNOLOGY_TETHERING_IDENTIFIER = 3, TECHNOLOGY_TETHERING_PASSPHRASE = 4, TECHNOLOGY_MAX = 5, }; static const char *Technology_updatable_properties[] = { "Powered", "Connected", "Tethering", "TetheringIdentifier", "TetheringPassphrase", }; struct connman_technology { char *path; char *name; char *type; gboolean powered; gboolean connected; gboolean tethering; char *tethering_identifier; char *tethering_passphrase; int update_index; guint property_changed_wid; guint to_update[TECHNOLOGY_MAX]; connman_property_changed_cb_f property_changed_cb; void *property_changed_user_data; connman_scan_cb_f scan_cb; DBusPendingCall *scan_call; void *scan_user_data; DBusPendingCall *call_modify[TECHNOLOGY_MAX]; guint to_error[TECHNOLOGY_MAX]; connman_property_set_cb_f property_set_error_cb; void *property_set_error_user_data; }; struct connman_technology_interface { DBusConnection *dbus_cnx; GHashTable *techs; gboolean set; connman_property_changed_cb_f property_changed_cb; void *property_user_data; connman_path_changed_cb_f added_cb; connman_path_changed_cb_f removed_cb; }; static struct connman_technology_interface *tech_if = NULL; static void technology_free(gpointer data) { struct connman_technology *technology = data; int i; if (technology->property_changed_wid != 0) g_dbus_remove_watch(tech_if->dbus_cnx, technology->property_changed_wid); for (i = 0; i < TECHNOLOGY_MAX; i++) { if (technology->to_update[i] != 0) g_source_remove(technology->to_update[i]); if (technology->call_modify[i] != 0) { dbus_pending_call_cancel(technology->call_modify[i]); dbus_pending_call_unref(technology->call_modify[i]); } if (technology->to_error[i] != 0) g_source_remove(technology->to_error[i]); } if (technology->scan_call != NULL) { dbus_pending_call_cancel(technology->scan_call); dbus_pending_call_unref(technology->scan_call); } g_free(technology->path); g_free(technology->name); g_free(technology->type); g_free(technology->tethering_identifier); g_free(technology->tethering_passphrase); g_free(technology); } static struct connman_technology *get_technology(const char *path) { if (path == NULL || tech_if == NULL) return NULL; return g_hash_table_lookup(tech_if->techs, path); } static void destroy_property(gpointer user_data) { struct property_change *property = user_data; struct connman_technology *technology; technology = get_technology(property->path); if (technology != NULL) { if (property->error != 0) technology->to_error[property->index] = 0; else technology->to_update[property->index] = 0; } g_free(property); } static gboolean property_changed_or_error(gpointer user_data) { struct property_change *property = user_data; struct connman_technology *technology; technology = get_technology(property->path); if (technology == NULL) return FALSE; if (property->error != 0) { if (technology->property_set_error_cb == NULL) return FALSE; technology->property_set_error_cb(property->path, property->name, property->error, technology->property_set_error_user_data); return FALSE; } if (tech_if->property_changed_cb != NULL) { tech_if->property_changed_cb(property->path, property->name, tech_if->property_user_data); } if (technology->property_changed_cb != NULL) { technology->property_changed_cb(property->path, property->name, technology->property_changed_user_data); } return FALSE; } static void property_update(struct connman_technology *technology, int index) { struct property_change *property; if (technology->property_changed_cb == NULL) return; property = g_try_malloc0(sizeof(struct property_change)); if (property == NULL) return; property->index = index; property->name = PROPERTY(index); property->path = technology->path; if (technology->to_update[index] != 0) g_source_remove(technology->to_update[index]); technology->to_update[index] = g_timeout_add_full(G_PRIORITY_DEFAULT, 0, property_changed_or_error, property, destroy_property); } static bool update_technology_property(DBusMessageIter *arg, void *user_data) { struct connman_technology *technology = user_data; const char *name, *value; if (cui_dbus_get_basic(arg, DBUS_TYPE_STRING, &name) != 0) return FALSE; dbus_message_iter_next(arg); if (g_strcmp0(name, "Name") == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value); technology->name = g_strdup(value); } else if (g_strcmp0(name, "Type") == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value); technology->type = g_strdup(value); } else if (g_strcmp0(name, PROPERTY(TECHNOLOGY_POWERED)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_BOOLEAN, &technology->powered); technology->update_index = TECHNOLOGY_POWERED; } else if (g_strcmp0(name, PROPERTY(TECHNOLOGY_CONNECTED)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_BOOLEAN, &technology->connected); technology->update_index = TECHNOLOGY_CONNECTED; } else if (g_strcmp0(name, PROPERTY(TECHNOLOGY_TETHERING)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_BOOLEAN, &technology->tethering); technology->update_index = TECHNOLOGY_TETHERING;; } else if (g_strcmp0(name, PROPERTY(TECHNOLOGY_TETHERING_IDENTIFIER)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value); g_free(technology->tethering_identifier); technology->tethering_identifier = g_strdup(value); technology->update_index = TECHNOLOGY_TETHERING_IDENTIFIER; } else if (g_strcmp0(name, PROPERTY(TECHNOLOGY_TETHERING_PASSPHRASE)) == 0) { cui_dbus_get_basic_variant(arg, DBUS_TYPE_STRING, &value); g_free(technology->tethering_passphrase); technology->tethering_passphrase = g_strdup(value); technology->update_index = TECHNOLOGY_TETHERING_PASSPHRASE; } if (technology->update_index < TECHNOLOGY_MAX) property_update(technology, technology->update_index); return FALSE; } static gboolean property_changed_signal_cb(DBusConnection *dbus_cnx, DBusMessage *message, void *user_data) { struct connman_technology *technology = user_data; DBusMessageIter arg; if (message == NULL) return TRUE; if (dbus_message_iter_init(message, &arg) == FALSE) return TRUE; technology->update_index = TECHNOLOGY_MAX; update_technology_property(&arg, technology); return TRUE; } static void update_or_create_technology(const char *obj_path, DBusMessageIter *dict) { struct connman_technology *technology; if (tech_if == NULL) return; technology = g_hash_table_lookup(tech_if->techs, obj_path); if (technology == NULL) { technology = g_try_malloc0(sizeof(struct connman_technology)); if (technology == NULL) return; technology->path = g_strdup(obj_path); g_hash_table_insert(tech_if->techs, technology->path, technology); technology->property_changed_wid = g_dbus_add_signal_watch( tech_if->dbus_cnx, CONNMAN_DBUS_NAME, technology->path, CONNMAN_TECHNOLOGY_INTERFACE, "PropertyChanged", property_changed_signal_cb, technology, NULL); } cui_dbus_foreach_dict_entry(dict, update_technology_property, technology); } static void technology_added_cb(DBusMessageIter *iter) { char *obj_path; if (iter == NULL) return; cui_dbus_get_basic(iter, DBUS_TYPE_OBJECT_PATH, &obj_path); dbus_message_iter_next(iter); update_or_create_technology(obj_path, iter); if (tech_if != NULL && tech_if->added_cb != NULL) tech_if->added_cb(obj_path); if (tech_if->set == TRUE) __connman_manager_get_technologies(get_technologies_cb); } static void technology_removed_cb(DBusMessageIter *iter) { char *obj_path; if (iter == NULL) return; cui_dbus_get_basic(iter, DBUS_TYPE_OBJECT_PATH, &obj_path); if (tech_if != NULL && tech_if->removed_cb != NULL) tech_if->removed_cb(obj_path); g_hash_table_remove(tech_if->techs, obj_path); } static void get_technologies_cb(DBusMessageIter *iter) { DBusMessageIter array; DBusMessageIter strt; char *obj_path; int arg_type; if (iter == NULL || tech_if == NULL) return; if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY) return; dbus_message_iter_recurse(iter, &array); arg_type = dbus_message_iter_get_arg_type(&array); while (arg_type != DBUS_TYPE_INVALID) { dbus_message_iter_recurse(&array, &strt); cui_dbus_get_basic(&strt, DBUS_TYPE_OBJECT_PATH, &obj_path); dbus_message_iter_next(&strt); update_or_create_technology(obj_path, &strt); dbus_message_iter_next(&array); arg_type = dbus_message_iter_get_arg_type(&array); } if (tech_if->set == FALSE) { if (__connman_manager_register_technology_signals( technology_added_cb, technology_removed_cb) == 0) tech_if->set = TRUE; __connman_manager_get_technologies(get_technologies_cb); } } static void scan_callback(DBusPendingCall *pending, void *user_data) { struct connman_technology *technology = user_data; if (dbus_pending_call_get_completed(pending) == FALSE) return; dbus_pending_call_unref(pending); technology->scan_call = NULL; if (technology->scan_cb != NULL) technology->scan_cb(technology->scan_user_data); } static void set_property_cb(DBusPendingCall *pending, void *user_data) { struct property_setting *set = user_data; struct connman_technology *technology; struct property_change *property; DBusMessage *reply; DBusError error; if (dbus_pending_call_get_completed(pending) == FALSE) return; if (set == NULL) return; technology = set->data; technology->call_modify[set->index] = NULL; if (technology->property_set_error_cb == NULL) return; property = g_try_malloc0(sizeof(struct property_change)); if (property == NULL) return; reply = dbus_pending_call_steal_reply(pending); if (reply == NULL) return; dbus_error_init(&error); if (dbus_set_error_from_message(&error, reply) == FALSE) goto done; printf("SetProperty Error: %s\n", error.message); dbus_error_free(&error); if (technology->property_set_error_cb == NULL) goto done; property = g_try_malloc0(sizeof(struct property_change)); if (property == NULL) goto done; property->path = technology->path; property->name = PROPERTY(set->index); property->error = -1; if (technology->to_error[set->index] != 0) g_source_remove(technology->to_error[set->index]); technology->to_error[set->index] = g_timeout_add_full( G_PRIORITY_DEFAULT, 0, property_changed_or_error, property, destroy_property); done: dbus_message_unref(reply); } static int set_technology_property(struct connman_technology *technology, enum connman_technology_property property, int dbus_type, void *data) { struct property_setting *set = NULL; const char *property_name; DBusMessage *message; DBusMessageIter arg; if (connman == NULL) return -EINVAL; if (technology->call_modify[property] != NULL) return -EINVAL; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, technology->path, CONNMAN_TECHNOLOGY_INTERFACE, "SetProperty"); if (message == NULL) return -ENOMEM; set = g_try_malloc0(sizeof(struct property_setting)); if (set == NULL) goto error; set->data = technology; set->index = property; property_name = PROPERTY(property); dbus_message_iter_init_append(message, &arg); cui_dbus_append_basic(&arg, property_name, dbus_type, data); if (dbus_connection_send_with_reply(tech_if->dbus_cnx, message, &technology->call_modify[property], DBUS_TIMEOUT_USE_DEFAULT) == FALSE) goto error; if (dbus_pending_call_set_notify(technology->call_modify[property], set_property_cb, set, g_free) == FALSE) goto error; return 0; error: dbus_message_unref(message); if (set == NULL) return -ENOMEM; g_free(set); return -EINVAL; } int connman_technology_init(void) { int ret; if (connman == NULL) return -EINVAL; if (tech_if != NULL) return 0; tech_if = g_try_malloc0(sizeof(struct connman_technology_interface)); if (tech_if == NULL) return -ENOMEM; tech_if->techs = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, technology_free); if (tech_if->techs == NULL) { g_free(tech_if); return -ENOMEM; } ret = __connman_manager_get_technologies(get_technologies_cb); if (ret < 0) return ret; tech_if->dbus_cnx = dbus_connection_ref(connman->dbus_cnx); return 0; } void connman_technology_finalize(void) { if (tech_if == NULL) return; __connman_manager_register_technology_signals(NULL, NULL); dbus_connection_unref(tech_if->dbus_cnx); g_hash_table_destroy(tech_if->techs); g_free(tech_if); tech_if = NULL; } void connman_technology_set_global_property_callback( connman_property_changed_cb_f property_changed_cb, void *user_data) { if (tech_if == NULL) return; tech_if->property_changed_cb = property_changed_cb; tech_if->property_user_data = user_data; } void connman_technology_set_property_changed_callback(const char *path, connman_property_changed_cb_f property_changed_cb, void *user_data) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return; technology->property_changed_cb = property_changed_cb; technology->property_changed_user_data = user_data; } void connman_technology_set_property_error_callback(const char *path, connman_property_set_cb_f property_set_cb, void *user_data) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return; technology->property_set_error_cb = property_set_cb; technology->property_set_error_user_data = user_data; } void connman_technology_set_removed_callback( connman_path_changed_cb_f removed_cb) { if (tech_if != NULL) tech_if->removed_cb = removed_cb; } void connman_technology_set_added_callback(connman_path_changed_cb_f added_cb) { if (tech_if != NULL) tech_if->added_cb = added_cb; } GList *connman_technology_get_technologies(void) { if (tech_if == NULL || tech_if->techs == NULL) return NULL; return g_hash_table_get_keys(tech_if->techs); } int connman_technology_scan(const char *path, connman_scan_cb_f callback, void *user_data) { struct connman_technology *technology; DBusMessage *message; technology = get_technology(path); if (technology == NULL) return -EINVAL; message = dbus_message_new_method_call(CONNMAN_DBUS_NAME, technology->path, CONNMAN_TECHNOLOGY_INTERFACE, "Scan"); if (message == NULL) return -ENOMEM; technology->scan_cb = callback; if (dbus_connection_send_with_reply(tech_if->dbus_cnx, message, &technology->scan_call, DBUS_TIMEOUT_USE_DEFAULT) == FALSE) goto error; if (dbus_pending_call_set_notify(technology->scan_call, scan_callback, technology, NULL) == FALSE) goto error; technology->scan_user_data = user_data; dbus_message_unref(message); return 0; error: dbus_message_unref(message); technology->scan_cb = NULL; return -EINVAL; } int connman_technology_enable(const char *path, gboolean enable) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return -EINVAL; if (technology->powered == enable) return 0; return set_technology_property(technology, TECHNOLOGY_POWERED, DBUS_TYPE_BOOLEAN, &enable); } int connman_technology_tether(const char *path, gboolean tethering) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return -EINVAL; if (technology->tethering == tethering) return 0; return set_technology_property(technology, TECHNOLOGY_TETHERING, DBUS_TYPE_BOOLEAN, &tethering); } int connman_technology_set_tethering_identifier(const char *path, const char *identifier) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return -EINVAL; return set_technology_property(technology, TECHNOLOGY_TETHERING_IDENTIFIER, DBUS_TYPE_STRING, &identifier); } int connman_technology_set_tethering_passphrase(const char *path, const char *passphrase) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return -EINVAL; return set_technology_property(technology, TECHNOLOGY_TETHERING_PASSPHRASE, DBUS_TYPE_STRING, &passphrase); } const char *connman_technology_get_name(const char *path) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return NULL; return technology->name; } const char *connman_technology_get_type(const char *path) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return NULL; return technology->type; } gboolean connman_technology_is_enabled(const char *path) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return FALSE; return technology->powered; } gboolean connman_technology_is_connected(const char *path) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return FALSE; return technology->connected; } gboolean connman_technology_is_tethering(const char *path) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return FALSE; return technology->tethering; } const char *connman_technology_get_tethering_identifier(const char *path) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return NULL; return technology->tethering_identifier; } const char *connman_technology_get_tethering_passphrase(const char *path) { struct connman_technology *technology; technology = get_technology(path); if (technology == NULL) return NULL; return technology->tethering_passphrase; } connman-ui-0_20150622+dfsg.orig/lib/dbus.c0000644000175000017500000003144312541725135016431 0ustar nicknick/* * Connection Manager UI * * Copyright (C) 2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 2.1, * as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * */ #include #include #include #include #include static const char *map_basic_to_signature(int dbus_type) { switch (dbus_type) { case DBUS_TYPE_BOOLEAN: return DBUS_TYPE_BOOLEAN_AS_STRING; case DBUS_TYPE_INT16: return DBUS_TYPE_INT16_AS_STRING; case DBUS_TYPE_UINT16: return DBUS_TYPE_UINT16_AS_STRING; case DBUS_TYPE_INT32: return DBUS_TYPE_INT32_AS_STRING; case DBUS_TYPE_UINT32: return DBUS_TYPE_UINT32_AS_STRING; case DBUS_TYPE_DOUBLE: return DBUS_TYPE_DOUBLE_AS_STRING; case DBUS_TYPE_STRING: return DBUS_TYPE_STRING_AS_STRING; case DBUS_TYPE_OBJECT_PATH: return DBUS_TYPE_OBJECT_PATH_AS_STRING; case DBUS_TYPE_SIGNATURE: return DBUS_TYPE_SIGNATURE_AS_STRING; case DBUS_TYPE_DICT_ENTRY: return DBUS_TYPE_DICT_ENTRY_AS_STRING; case DBUS_TYPE_BYTE: return DBUS_TYPE_BYTE_AS_STRING; default: break; } return DBUS_TYPE_VARIANT_AS_STRING; } static const char *map_array_to_signature(int dbus_type) { switch (dbus_type) { case DBUS_TYPE_BOOLEAN: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BOOLEAN_AS_STRING; case DBUS_TYPE_INT16: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT16_AS_STRING; case DBUS_TYPE_UINT16: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_UINT16_AS_STRING; case DBUS_TYPE_INT32: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_INT32_AS_STRING; case DBUS_TYPE_UINT32: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_UINT32_AS_STRING; case DBUS_TYPE_DOUBLE: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_DOUBLE_AS_STRING; case DBUS_TYPE_STRING: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING; case DBUS_TYPE_OBJECT_PATH: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING; case DBUS_TYPE_SIGNATURE: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_SIGNATURE_AS_STRING; case DBUS_TYPE_DICT_ENTRY: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_DICT_ENTRY_AS_STRING; case DBUS_TYPE_BYTE: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_ARRAY_AS_STRING; default: break; } return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_VARIANT_AS_STRING; } void cui_dbus_append_dict(DBusMessageIter *iter, const char *key_name, cui_dbus_property_f property_function, void *user_data) { DBusMessageIter dict, variant, *vdict; if (key_name != NULL) { dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key_name); dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &variant); vdict = &variant; } else vdict = iter; dbus_message_iter_open_container(vdict, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); if (property_function != NULL) property_function(&dict, user_data); dbus_message_iter_close_container(vdict, &dict); if (key_name != NULL) dbus_message_iter_close_container(iter, &variant); } void cui_dbus_append_basic(DBusMessageIter *iter, const char *key_name, int dbus_type, void *value) { if (key_name != NULL) { DBusMessageIter basic; dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key_name); dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, map_basic_to_signature(dbus_type), &basic); dbus_message_iter_append_basic(&basic, dbus_type, value); dbus_message_iter_close_container(iter, &basic); } else dbus_message_iter_append_basic(iter, dbus_type, value); } void cui_dbus_append_array(DBusMessageIter *iter, const char *key_name, int dbus_type, cui_dbus_property_f property_function, void *user_data) { DBusMessageIter variant, array, *varray; if (key_name != NULL) { dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key_name); dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, map_array_to_signature(dbus_type), &variant); varray = &variant; } else varray = iter; dbus_message_iter_open_container(varray, DBUS_TYPE_ARRAY, map_basic_to_signature(dbus_type), &array); if (property_function != NULL) property_function(&array, user_data); dbus_message_iter_close_container(varray, &array); if (key_name != NULL) dbus_message_iter_close_container(iter, &variant); } void cui_dbus_append_fixed_array(DBusMessageIter *iter, const char *key_name, int dbus_type, int length, void *value) { DBusMessageIter variant, array, *varray; if (key_name != NULL) { dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key_name); dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, map_array_to_signature(DBUS_TYPE_BYTE), &variant); varray = &variant; } else varray = iter; dbus_message_iter_open_container(varray, DBUS_TYPE_ARRAY, map_basic_to_signature(DBUS_TYPE_BYTE), &array); dbus_message_iter_append_fixed_array(&array, dbus_type, value, length); dbus_message_iter_close_container(varray, &array); if (key_name != NULL) dbus_message_iter_close_container(iter, &variant); } void cui_dbus_append_dict_entry(DBusMessageIter *dict, const char *key_name, enum cui_dbus_entry entry_type, int dbus_type, int length, cui_dbus_property_f property_function, void *user_data) { DBusMessageIter entry; dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); switch (entry_type) { case CUI_DBUS_ENTRY_BASIC: cui_dbus_append_basic(&entry, key_name, dbus_type, user_data); break; case CUI_DBUS_ENTRY_ARRAY: cui_dbus_append_array(&entry, key_name, dbus_type, property_function, user_data); break; case CUI_DBUS_ENTRY_FIXED_ARRAY: cui_dbus_append_fixed_array(&entry, key_name, dbus_type, length, user_data); break; case CUI_DBUS_ENTRY_DICT: cui_dbus_append_dict(&entry, key_name, property_function, user_data); break; default: break; } dbus_message_iter_close_container(dict, &entry); } int cui_dbus_get_basic(DBusMessageIter *iter, int dbus_type, void *destination) { if (destination == NULL) return -EINVAL; if (dbus_message_iter_get_arg_type(iter) != dbus_type) return -EINVAL; dbus_message_iter_get_basic(iter, destination); return 0; } int cui_dbus_get_basic_variant(DBusMessageIter *iter, int dbus_type, void *destination) { DBusMessageIter variant; if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT) return -EINVAL; dbus_message_iter_recurse(iter, &variant); if (dbus_message_iter_get_arg_type(&variant) != dbus_type) return -EINVAL; dbus_message_iter_get_basic(&variant, destination); return 0; } int cui_dbus_get_array(DBusMessageIter *iter, int dbus_type, int *length, void *destination) { DBusMessageIter variant, array; void **value_array = NULL; int iteration; int arg_type; size_t size; if (length == NULL || destination == NULL) return -EINVAL; switch (dbus_type) { case DBUS_TYPE_BOOLEAN: case DBUS_TYPE_INT16: case DBUS_TYPE_INT32: case DBUS_TYPE_UINT16: case DBUS_TYPE_UINT32: size = sizeof(int); break; case DBUS_TYPE_DOUBLE: size = sizeof(double); break; case DBUS_TYPE_STRING: case DBUS_TYPE_OBJECT_PATH: case DBUS_TYPE_SIGNATURE: size = sizeof(char *); break; default: return -EINVAL; } *length = 0; iteration = 0; *((void **) destination) = NULL; arg_type = dbus_message_iter_get_arg_type(iter); if (arg_type == DBUS_TYPE_VARIANT) { dbus_message_iter_recurse(iter, &variant); dbus_message_iter_recurse(&variant, &array); } else dbus_message_iter_recurse(iter, &array); arg_type = dbus_message_iter_get_arg_type(&array); while (arg_type != DBUS_TYPE_INVALID) { void **new_array; iteration++; new_array = realloc(value_array, size * (iteration + 1)); if (new_array == NULL) goto error; value_array = new_array; if (arg_type == DBUS_TYPE_VARIANT) { if (cui_dbus_get_basic_variant(&array, dbus_type, &value_array[iteration-1]) != 0) goto error; } else dbus_message_iter_get_basic(&array, &value_array[iteration-1]); dbus_message_iter_next(&array); arg_type = dbus_message_iter_get_arg_type(&array); } if (iteration > 0) { value_array[iteration] = NULL; *length = iteration - 1; } *((void **) destination) = value_array; return 0; error: if (value_array != NULL) free(value_array); return -ENOMEM; } int cui_dbus_get_fixed_array(DBusMessageIter *iter, int *length, void *destination) { DBusMessageIter farray; if (length == NULL || destination == NULL) return -EINVAL; if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY) return -EINVAL; if (dbus_message_iter_get_element_type(iter) != DBUS_TYPE_BYTE) return -EINVAL; dbus_message_iter_recurse(iter, &farray); dbus_message_iter_get_fixed_array(&farray, destination, length); return 0; } static int cui_dbus_get(DBusMessageIter *iter, enum cui_dbus_entry entry_type, int dbus_type, int *length, void *destination) { switch (entry_type) { case CUI_DBUS_ENTRY_BASIC: return cui_dbus_get_basic(iter, dbus_type, destination); case CUI_DBUS_ENTRY_ARRAY: return cui_dbus_get_array(iter, dbus_type, length, destination); case CUI_DBUS_ENTRY_FIXED_ARRAY: return cui_dbus_get_fixed_array(iter, length, destination); case CUI_DBUS_ENTRY_DICT: if (destination == NULL) return -EINVAL; dbus_message_iter_recurse(iter, (DBusMessageIter *)destination); return 0; default: break; } return -EINVAL; } int cui_dbus_foreach_dict_entry(DBusMessageIter *iter, cui_dbus_foreach_callback_f callback, void *user_data) { DBusMessageIter array, dict_entry; int arg_type; arg_type = dbus_message_iter_get_arg_type(iter); if (arg_type != DBUS_TYPE_ARRAY) return -EINVAL; if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_BYTE) return -EINVAL; dbus_message_iter_recurse(iter, &array); arg_type = dbus_message_iter_get_arg_type(&array); while (arg_type != DBUS_TYPE_INVALID) { if (arg_type != DBUS_TYPE_DICT_ENTRY) return -EINVAL; dbus_message_iter_recurse(&array, &dict_entry); if (callback(&dict_entry, user_data) == TRUE) return 0; dbus_message_iter_next(&array); arg_type = dbus_message_iter_get_arg_type(&array); } return -EINVAL; } struct dict_entry_parameters { const char *key_name; enum cui_dbus_entry entry_type; int dbus_type; int *length; void *destination; }; static bool get_dict_entry_cb(DBusMessageIter *iter, void *user_data) { struct dict_entry_parameters *param = user_data; DBusMessageIter dict_value; char *name; dbus_message_iter_get_basic(iter, &name); if (strncmp(param->key_name, name, strlen(param->key_name)) == 0) { dbus_message_iter_next(iter); dbus_message_iter_recurse(iter, &dict_value); cui_dbus_get(&dict_value, param->entry_type, param->dbus_type, param->length, param->destination); return TRUE; } return FALSE; } int cui_dbus_get_dict_entry(DBusMessageIter *iter, const char *key_name, enum cui_dbus_entry entry_type, int dbus_type, int *length, void *destination) { struct dict_entry_parameters param; if (key_name == NULL) return -EINVAL; param.key_name = key_name; param.entry_type = entry_type; param.dbus_type = dbus_type; param.length = length; param.destination = destination; return cui_dbus_foreach_dict_entry(iter, get_dict_entry_cb, ¶m); } int cui_dbus_get_struct_entry(DBusMessageIter *iter, unsigned int position, enum cui_dbus_entry entry_type, int dbus_type, int *length, void *destination) { DBusMessageIter struct_entry; unsigned int current = 1; int arg_type; arg_type = dbus_message_iter_get_arg_type(iter); if (arg_type != DBUS_TYPE_STRUCT) return -EINVAL; dbus_message_iter_recurse(iter, &struct_entry); arg_type = dbus_message_iter_get_arg_type(&struct_entry); while (arg_type != DBUS_TYPE_INVALID) { if (position != current) { dbus_message_iter_next(&struct_entry); arg_type = dbus_message_iter_get_arg_type(&struct_entry); current++; continue; } return cui_dbus_get(&struct_entry, entry_type, dbus_type, length, destination); } return -EINVAL; } connman-ui-0_20150622+dfsg.orig/autogen.sh0000755000175000017500000000006012541725135016552 0ustar nicknick#!/bin/sh set -e autoreconf --install --verbose connman-ui-0_20150622+dfsg.orig/configure.ac0000644000175000017500000000310112541725135017036 0ustar nicknickAC_PREREQ(2.60) AC_INIT(connman-ui, 0.1) AM_INIT_AUTOMAKE([foreign subdir-objects]) AC_CONFIG_HEADERS([config.h]) AC_CONFIG_MACRO_DIR([m4]) m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) AM_MAINTAINER_MODE AC_PREFIX_DEFAULT(/usr/local) PKG_PROG_PKG_CONFIG AC_SUBST(abs_top_srcdir) AC_SUBST(abs_top_builddir) AC_LANG_C AC_PROG_CC AM_PROG_CC_C_O AC_PROG_INSTALL AC_PROG_MKDIR_P m4_define([_LT_AC_TAGCONFIG], []) m4_ifdef([AC_LIBTOOL_TAGS], [AC_LIBTOOL_TAGS([])]) AC_DISABLE_STATIC AC_PROG_LIBTOOL IT_PROG_INTLTOOL GETTEXT_PACKAGE=connman-ui AC_SUBST(GETTEXT_PACKAGE) AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"], [The domain to use with gettext]) AM_GLIB_GNU_GETTEXT AC_ARG_ENABLE(optimization, AC_HELP_STRING([--disable-optimization], [disable code optimization through compiler]), [ if (test "${enableval}" = "no"); then CFLAGS="$CFLAGS -O0" fi ]) AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug], [enable compiling with debugging information]), [ if (test "${enableval}" = "yes" && test "${ac_cv_prog_cc_g}" = "yes"); then CFLAGS="$CFLAGS -g -Wall" fi ]) PKG_CHECK_MODULES(GTK, gtk+-3.0 >= 3.0, dummy=yes, AC_MSG_ERROR(gtk+ >= 3.0 is required)) AC_SUBST(GTK_CFLAGS) AC_SUBST(GTK_LIBS) PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.28, dummy=yes, AC_MSG_ERROR(GLib >= 2.28 is required)) AC_SUBST(GLIB_CFLAGS) AC_SUBST(GLIB_LIBS) PKG_CHECK_MODULES(DBUS, dbus-1 >= 1.4, dummy=yes, AC_MSG_ERROR(D-Bus >= 1.4 is required)) AC_SUBST(DBUS_CFLAGS) AC_SUBST(DBUS_LIBS) AC_OUTPUT(Makefile include/version.h po/Makefile.in) connman-ui-0_20150622+dfsg.orig/m4/0000755000175000017500000000000013257457474015112 5ustar nicknickconnman-ui-0_20150622+dfsg.orig/m4/ChangeLog0000644000175000017500000000272012541725135016650 0ustar nicknick2012-09-18 gettextize * gettext.m4: New file, from gettext-0.18.1. * iconv.m4: New file, from gettext-0.18.1. * lib-ld.m4: New file, from gettext-0.18.1. * lib-link.m4: New file, from gettext-0.18.1. * lib-prefix.m4: New file, from gettext-0.18.1. * nls.m4: New file, from gettext-0.18.1. * po.m4: New file, from gettext-0.18.1. * progtest.m4: New file, from gettext-0.18.1. * codeset.m4: New file, from gettext-0.18.1. * fcntl-o.m4: New file, from gettext-0.18.1. * glibc2.m4: New file, from gettext-0.18.1. * glibc21.m4: New file, from gettext-0.18.1. * intdiv0.m4: New file, from gettext-0.18.1. * intl.m4: New file, from gettext-0.18.1. * intldir.m4: New file, from gettext-0.18.1. * intlmacosx.m4: New file, from gettext-0.18.1. * intmax.m4: New file, from gettext-0.18.1. * inttypes_h.m4: New file, from gettext-0.18.1. * inttypes-pri.m4: New file, from gettext-0.18.1. * lcmessage.m4: New file, from gettext-0.18.1. * lock.m4: New file, from gettext-0.18.1. * longlong.m4: New file, from gettext-0.18.1. * printf-posix.m4: New file, from gettext-0.18.1. * size_max.m4: New file, from gettext-0.18.1. * stdint_h.m4: New file, from gettext-0.18.1. * threadlib.m4: New file, from gettext-0.18.1. * uintmax_t.m4: New file, from gettext-0.18.1. * visibility.m4: New file, from gettext-0.18.1. * wchar_t.m4: New file, from gettext-0.18.1. * wint_t.m4: New file, from gettext-0.18.1. * xsize.m4: New file, from gettext-0.18.1. connman-ui-0_20150622+dfsg.orig/m4/ltoptions.m40000644000175000017500000002725612541725135017406 0ustar nicknick# Helper functions for option handling. -*- Autoconf -*- # # Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, # Inc. # Written by Gary V. Vaughan, 2004 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # serial 7 ltoptions.m4 # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) # _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME) # ------------------------------------------ m4_define([_LT_MANGLE_OPTION], [[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])]) # _LT_SET_OPTION(MACRO-NAME, OPTION-NAME) # --------------------------------------- # Set option OPTION-NAME for macro MACRO-NAME, and if there is a # matching handler defined, dispatch to it. Other OPTION-NAMEs are # saved as a flag. m4_define([_LT_SET_OPTION], [m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), _LT_MANGLE_DEFUN([$1], [$2]), [m4_warning([Unknown $1 option `$2'])])[]dnl ]) # _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET]) # ------------------------------------------------------------ # Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. m4_define([_LT_IF_OPTION], [m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])]) # _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET) # ------------------------------------------------------- # Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME # are set. m4_define([_LT_UNLESS_OPTIONS], [m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option), [m4_define([$0_found])])])[]dnl m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3 ])[]dnl ]) # _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST) # ---------------------------------------- # OPTION-LIST is a space-separated list of Libtool options associated # with MACRO-NAME. If any OPTION has a matching handler declared with # LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about # the unknown option and exit. m4_defun([_LT_SET_OPTIONS], [# Set options m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), [_LT_SET_OPTION([$1], _LT_Option)]) m4_if([$1],[LT_INIT],[ dnl dnl Simply set some default values (i.e off) if boolean options were not dnl specified: _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no ]) _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no ]) dnl dnl If no reference was made to various pairs of opposing options, then dnl we run the default mode handler for the pair. For example, if neither dnl `shared' nor `disable-shared' was passed, we enable building of shared dnl archives by default: _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], [_LT_ENABLE_FAST_INSTALL]) ]) ])# _LT_SET_OPTIONS ## --------------------------------- ## ## Macros to handle LT_INIT options. ## ## --------------------------------- ## # _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME) # ----------------------------------------- m4_define([_LT_MANGLE_DEFUN], [[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])]) # LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE) # ----------------------------------------------- m4_define([LT_OPTION_DEFINE], [m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl ])# LT_OPTION_DEFINE # dlopen # ------ LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes ]) AU_DEFUN([AC_LIBTOOL_DLOPEN], [_LT_SET_OPTION([LT_INIT], [dlopen]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `dlopen' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], []) # win32-dll # --------- # Declare package support for building win32 dll's. LT_OPTION_DEFINE([LT_INIT], [win32-dll], [enable_win32_dll=yes case $host in *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) AC_CHECK_TOOL(AS, as, false) AC_CHECK_TOOL(DLLTOOL, dlltool, false) AC_CHECK_TOOL(OBJDUMP, objdump, false) ;; esac test -z "$AS" && AS=as _LT_DECL([], [AS], [1], [Assembler program])dnl test -z "$DLLTOOL" && DLLTOOL=dlltool _LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl test -z "$OBJDUMP" && OBJDUMP=objdump _LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl ])# win32-dll AU_DEFUN([AC_LIBTOOL_WIN32_DLL], [AC_REQUIRE([AC_CANONICAL_HOST])dnl _LT_SET_OPTION([LT_INIT], [win32-dll]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `win32-dll' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) # _LT_ENABLE_SHARED([DEFAULT]) # ---------------------------- # implement the --enable-shared flag, and supports the `shared' and # `disable-shared' LT_INIT options. # DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. m4_define([_LT_ENABLE_SHARED], [m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([shared], [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@], [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])], [p=${PACKAGE-default} case $enableval in yes) enable_shared=yes ;; no) enable_shared=no ;; *) enable_shared=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_shared=yes fi done IFS="$lt_save_ifs" ;; esac], [enable_shared=]_LT_ENABLE_SHARED_DEFAULT) _LT_DECL([build_libtool_libs], [enable_shared], [0], [Whether or not to build shared libraries]) ])# _LT_ENABLE_SHARED LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])]) # Old names: AC_DEFUN([AC_ENABLE_SHARED], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) ]) AC_DEFUN([AC_DISABLE_SHARED], [_LT_SET_OPTION([LT_INIT], [disable-shared]) ]) AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_ENABLE_SHARED], []) dnl AC_DEFUN([AM_DISABLE_SHARED], []) # _LT_ENABLE_STATIC([DEFAULT]) # ---------------------------- # implement the --enable-static flag, and support the `static' and # `disable-static' LT_INIT options. # DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. m4_define([_LT_ENABLE_STATIC], [m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([static], [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@], [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])], [p=${PACKAGE-default} case $enableval in yes) enable_static=yes ;; no) enable_static=no ;; *) enable_static=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_static=yes fi done IFS="$lt_save_ifs" ;; esac], [enable_static=]_LT_ENABLE_STATIC_DEFAULT) _LT_DECL([build_old_libs], [enable_static], [0], [Whether or not to build static libraries]) ])# _LT_ENABLE_STATIC LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])]) # Old names: AC_DEFUN([AC_ENABLE_STATIC], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) ]) AC_DEFUN([AC_DISABLE_STATIC], [_LT_SET_OPTION([LT_INIT], [disable-static]) ]) AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_ENABLE_STATIC], []) dnl AC_DEFUN([AM_DISABLE_STATIC], []) # _LT_ENABLE_FAST_INSTALL([DEFAULT]) # ---------------------------------- # implement the --enable-fast-install flag, and support the `fast-install' # and `disable-fast-install' LT_INIT options. # DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. m4_define([_LT_ENABLE_FAST_INSTALL], [m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl AC_ARG_ENABLE([fast-install], [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], [p=${PACKAGE-default} case $enableval in yes) enable_fast_install=yes ;; no) enable_fast_install=no ;; *) enable_fast_install=no # Look at the argument we got. We use all the common list separators. lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," for pkg in $enableval; do IFS="$lt_save_ifs" if test "X$pkg" = "X$p"; then enable_fast_install=yes fi done IFS="$lt_save_ifs" ;; esac], [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) _LT_DECL([fast_install], [enable_fast_install], [0], [Whether or not to optimize for fast installation])dnl ])# _LT_ENABLE_FAST_INSTALL LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])]) LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])]) # Old names: AU_DEFUN([AC_ENABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `fast-install' option into LT_INIT's first parameter.]) ]) AU_DEFUN([AC_DISABLE_FAST_INSTALL], [_LT_SET_OPTION([LT_INIT], [disable-fast-install]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `disable-fast-install' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) # _LT_WITH_PIC([MODE]) # -------------------- # implement the --with-pic flag, and support the `pic-only' and `no-pic' # LT_INIT options. # MODE is either `yes' or `no'. If omitted, it defaults to `both'. m4_define([_LT_WITH_PIC], [AC_ARG_WITH([pic], [AS_HELP_STRING([--with-pic], [try to use only PIC/non-PIC objects @<:@default=use both@:>@])], [pic_mode="$withval"], [pic_mode=default]) test -z "$pic_mode" && pic_mode=m4_default([$1], [default]) _LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl ])# _LT_WITH_PIC LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])]) LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])]) # Old name: AU_DEFUN([AC_LIBTOOL_PICMODE], [_LT_SET_OPTION([LT_INIT], [pic-only]) AC_DIAGNOSE([obsolete], [$0: Remove this warning and the call to _LT_SET_OPTION when you put the `pic-only' option into LT_INIT's first parameter.]) ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_PICMODE], []) ## ----------------- ## ## LTDL_INIT Options ## ## ----------------- ## m4_define([_LTDL_MODE], []) LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive], [m4_define([_LTDL_MODE], [nonrecursive])]) LT_OPTION_DEFINE([LTDL_INIT], [recursive], [m4_define([_LTDL_MODE], [recursive])]) LT_OPTION_DEFINE([LTDL_INIT], [subproject], [m4_define([_LTDL_MODE], [subproject])]) m4_define([_LTDL_TYPE], []) LT_OPTION_DEFINE([LTDL_INIT], [installable], [m4_define([_LTDL_TYPE], [installable])]) LT_OPTION_DEFINE([LTDL_INIT], [convenience], [m4_define([_LTDL_TYPE], [convenience])]) connman-ui-0_20150622+dfsg.orig/m4/lock.m40000644000175000017500000000231412541725135016267 0ustar nicknick# lock.m4 serial 10 (gettext-0.18) dnl Copyright (C) 2005-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. AC_DEFUN([gl_LOCK], [ AC_REQUIRE([gl_THREADLIB]) if test "$gl_threads_api" = posix; then # OSF/1 4.0 and MacOS X 10.1 lack the pthread_rwlock_t type and the # pthread_rwlock_* functions. AC_CHECK_TYPE([pthread_rwlock_t], [AC_DEFINE([HAVE_PTHREAD_RWLOCK], [1], [Define if the POSIX multithreading library has read/write locks.])], [], [#include ]) # glibc defines PTHREAD_MUTEX_RECURSIVE as enum, not as a macro. AC_TRY_COMPILE([#include ], [#if __FreeBSD__ == 4 error "No, in FreeBSD 4.0 recursive mutexes actually don't work." #else int x = (int)PTHREAD_MUTEX_RECURSIVE; return !x; #endif], [AC_DEFINE([HAVE_PTHREAD_MUTEX_RECURSIVE], [1], [Define if the defines PTHREAD_MUTEX_RECURSIVE.])]) fi gl_PREREQ_LOCK ]) # Prerequisites of lib/lock.c. AC_DEFUN([gl_PREREQ_LOCK], [ AC_REQUIRE([AC_C_INLINE]) ]) connman-ui-0_20150622+dfsg.orig/m4/inttypes_h.m40000644000175000017500000000167112541725135017532 0ustar nicknick# inttypes_h.m4 serial 9 dnl Copyright (C) 1997-2004, 2006, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Paul Eggert. # Define HAVE_INTTYPES_H_WITH_UINTMAX if exists, # doesn't clash with , and declares uintmax_t. AC_DEFUN([gl_AC_HEADER_INTTYPES_H], [ AC_CACHE_CHECK([for inttypes.h], [gl_cv_header_inttypes_h], [AC_TRY_COMPILE( [#include #include ], [uintmax_t i = (uintmax_t) -1; return !i;], [gl_cv_header_inttypes_h=yes], [gl_cv_header_inttypes_h=no])]) if test $gl_cv_header_inttypes_h = yes; then AC_DEFINE_UNQUOTED([HAVE_INTTYPES_H_WITH_UINTMAX], [1], [Define if exists, doesn't clash with , and declares uintmax_t. ]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/glibc2.m40000644000175000017500000000143512541725135016504 0ustar nicknick# glibc2.m4 serial 2 dnl Copyright (C) 2000-2002, 2004, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. # Test for the GNU C Library, version 2.0 or newer. # From Bruno Haible. AC_DEFUN([gt_GLIBC2], [ AC_CACHE_CHECK([whether we are using the GNU C Library 2 or newer], [ac_cv_gnu_library_2], [AC_EGREP_CPP([Lucky GNU user], [ #include #ifdef __GNU_LIBRARY__ #if (__GLIBC__ >= 2) Lucky GNU user #endif #endif ], [ac_cv_gnu_library_2=yes], [ac_cv_gnu_library_2=no]) ] ) AC_SUBST([GLIBC2]) GLIBC2="$ac_cv_gnu_library_2" ] ) connman-ui-0_20150622+dfsg.orig/m4/lcmessage.m40000644000175000017500000000243312541725135017304 0ustar nicknick# lcmessage.m4 serial 6 (gettext-0.18) dnl Copyright (C) 1995-2002, 2004-2005, 2008-2010 Free Software Foundation, dnl Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl dnl This file can can be used in projects which are not available under dnl the GNU General Public License or the GNU Library General Public dnl License but which still want to provide support for the GNU gettext dnl functionality. dnl Please note that the actual code of the GNU gettext library is covered dnl by the GNU Library General Public License, and the rest of the GNU dnl gettext package package is covered by the GNU General Public License. dnl They are *not* in the public domain. dnl Authors: dnl Ulrich Drepper , 1995. # Check whether LC_MESSAGES is available in . AC_DEFUN([gt_LC_MESSAGES], [ AC_CACHE_CHECK([for LC_MESSAGES], [gt_cv_val_LC_MESSAGES], [AC_TRY_LINK([#include ], [return LC_MESSAGES], [gt_cv_val_LC_MESSAGES=yes], [gt_cv_val_LC_MESSAGES=no])]) if test $gt_cv_val_LC_MESSAGES = yes; then AC_DEFINE([HAVE_LC_MESSAGES], [1], [Define if your file defines LC_MESSAGES.]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/size_max.m40000644000175000017500000000563012541725135017162 0ustar nicknick# size_max.m4 serial 9 dnl Copyright (C) 2003, 2005-2006, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. AC_DEFUN([gl_SIZE_MAX], [ AC_CHECK_HEADERS([stdint.h]) dnl First test whether the system already has SIZE_MAX. AC_CACHE_CHECK([for SIZE_MAX], [gl_cv_size_max], [ gl_cv_size_max= AC_EGREP_CPP([Found it], [ #include #if HAVE_STDINT_H #include #endif #ifdef SIZE_MAX Found it #endif ], [gl_cv_size_max=yes]) if test -z "$gl_cv_size_max"; then dnl Define it ourselves. Here we assume that the type 'size_t' is not wider dnl than the type 'unsigned long'. Try hard to find a definition that can dnl be used in a preprocessor #if, i.e. doesn't contain a cast. AC_COMPUTE_INT([size_t_bits_minus_1], [sizeof (size_t) * CHAR_BIT - 1], [#include #include ], [size_t_bits_minus_1=]) AC_COMPUTE_INT([fits_in_uint], [sizeof (size_t) <= sizeof (unsigned int)], [#include ], [fits_in_uint=]) if test -n "$size_t_bits_minus_1" && test -n "$fits_in_uint"; then if test $fits_in_uint = 1; then dnl Even though SIZE_MAX fits in an unsigned int, it must be of type dnl 'unsigned long' if the type 'size_t' is the same as 'unsigned long'. AC_TRY_COMPILE([#include extern size_t foo; extern unsigned long foo; ], [], [fits_in_uint=0]) fi dnl We cannot use 'expr' to simplify this expression, because 'expr' dnl works only with 'long' integers in the host environment, while we dnl might be cross-compiling from a 32-bit platform to a 64-bit platform. if test $fits_in_uint = 1; then gl_cv_size_max="(((1U << $size_t_bits_minus_1) - 1) * 2 + 1)" else gl_cv_size_max="(((1UL << $size_t_bits_minus_1) - 1) * 2 + 1)" fi else dnl Shouldn't happen, but who knows... gl_cv_size_max='((size_t)~(size_t)0)' fi fi ]) if test "$gl_cv_size_max" != yes; then AC_DEFINE_UNQUOTED([SIZE_MAX], [$gl_cv_size_max], [Define as the maximum value of type 'size_t', if the system doesn't define it.]) fi dnl Don't redefine SIZE_MAX in config.h if config.h is re-included after dnl . Remember that the #undef in AH_VERBATIM gets replaced with dnl #define by AC_DEFINE_UNQUOTED. AH_VERBATIM([SIZE_MAX], [/* Define as the maximum value of type 'size_t', if the system doesn't define it. */ #ifndef SIZE_MAX # undef SIZE_MAX #endif]) ]) dnl Autoconf >= 2.61 has AC_COMPUTE_INT built-in. dnl Remove this when we can assume autoconf >= 2.61. m4_ifdef([AC_COMPUTE_INT], [], [ AC_DEFUN([AC_COMPUTE_INT], [_AC_COMPUTE_INT([$2],[$1],[$3],[$4])]) ]) connman-ui-0_20150622+dfsg.orig/m4/xsize.m40000644000175000017500000000066212541725135016505 0ustar nicknick# xsize.m4 serial 4 dnl Copyright (C) 2003-2004, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. AC_DEFUN([gl_XSIZE], [ dnl Prerequisites of lib/xsize.h. AC_REQUIRE([gl_SIZE_MAX]) AC_REQUIRE([AC_C_INLINE]) AC_CHECK_HEADERS([stdint.h]) ]) connman-ui-0_20150622+dfsg.orig/m4/longlong.m40000644000175000017500000001057512541725135017166 0ustar nicknick# longlong.m4 serial 14 dnl Copyright (C) 1999-2007, 2009-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Paul Eggert. # Define HAVE_LONG_LONG_INT if 'long long int' works. # This fixes a bug in Autoconf 2.61, but can be removed once we # assume 2.62 everywhere. # Note: If the type 'long long int' exists but is only 32 bits large # (as on some very old compilers), HAVE_LONG_LONG_INT will not be # defined. In this case you can treat 'long long int' like 'long int'. AC_DEFUN([AC_TYPE_LONG_LONG_INT], [ AC_CACHE_CHECK([for long long int], [ac_cv_type_long_long_int], [AC_LINK_IFELSE( [_AC_TYPE_LONG_LONG_SNIPPET], [dnl This catches a bug in Tandem NonStop Kernel (OSS) cc -O circa 2004. dnl If cross compiling, assume the bug isn't important, since dnl nobody cross compiles for this platform as far as we know. AC_RUN_IFELSE( [AC_LANG_PROGRAM( [[@%:@include @%:@ifndef LLONG_MAX @%:@ define HALF \ (1LL << (sizeof (long long int) * CHAR_BIT - 2)) @%:@ define LLONG_MAX (HALF - 1 + HALF) @%:@endif]], [[long long int n = 1; int i; for (i = 0; ; i++) { long long int m = n << i; if (m >> i != n) return 1; if (LLONG_MAX / 2 < m) break; } return 0;]])], [ac_cv_type_long_long_int=yes], [ac_cv_type_long_long_int=no], [ac_cv_type_long_long_int=yes])], [ac_cv_type_long_long_int=no])]) if test $ac_cv_type_long_long_int = yes; then AC_DEFINE([HAVE_LONG_LONG_INT], [1], [Define to 1 if the system has the type `long long int'.]) fi ]) # Define HAVE_UNSIGNED_LONG_LONG_INT if 'unsigned long long int' works. # This fixes a bug in Autoconf 2.61, but can be removed once we # assume 2.62 everywhere. # Note: If the type 'unsigned long long int' exists but is only 32 bits # large (as on some very old compilers), AC_TYPE_UNSIGNED_LONG_LONG_INT # will not be defined. In this case you can treat 'unsigned long long int' # like 'unsigned long int'. AC_DEFUN([AC_TYPE_UNSIGNED_LONG_LONG_INT], [ AC_CACHE_CHECK([for unsigned long long int], [ac_cv_type_unsigned_long_long_int], [AC_LINK_IFELSE( [_AC_TYPE_LONG_LONG_SNIPPET], [ac_cv_type_unsigned_long_long_int=yes], [ac_cv_type_unsigned_long_long_int=no])]) if test $ac_cv_type_unsigned_long_long_int = yes; then AC_DEFINE([HAVE_UNSIGNED_LONG_LONG_INT], [1], [Define to 1 if the system has the type `unsigned long long int'.]) fi ]) # Expands to a C program that can be used to test for simultaneous support # of 'long long' and 'unsigned long long'. We don't want to say that # 'long long' is available if 'unsigned long long' is not, or vice versa, # because too many programs rely on the symmetry between signed and unsigned # integer types (excluding 'bool'). AC_DEFUN([_AC_TYPE_LONG_LONG_SNIPPET], [ AC_LANG_PROGRAM( [[/* For now, do not test the preprocessor; as of 2007 there are too many implementations with broken preprocessors. Perhaps this can be revisited in 2012. In the meantime, code should not expect #if to work with literals wider than 32 bits. */ /* Test literals. */ long long int ll = 9223372036854775807ll; long long int nll = -9223372036854775807LL; unsigned long long int ull = 18446744073709551615ULL; /* Test constant expressions. */ typedef int a[((-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) ? 1 : -1)]; typedef int b[(18446744073709551615ULL <= (unsigned long long int) -1 ? 1 : -1)]; int i = 63;]], [[/* Test availability of runtime routines for shift and division. */ long long int llmax = 9223372036854775807ll; unsigned long long int ullmax = 18446744073709551615ull; return ((ll << 63) | (ll >> 63) | (ll < i) | (ll > i) | (llmax / ll) | (llmax % ll) | (ull << 63) | (ull >> 63) | (ull << i) | (ull >> i) | (ullmax / ull) | (ullmax % ull));]]) ]) connman-ui-0_20150622+dfsg.orig/m4/intldir.m40000644000175000017500000000163312541725135017007 0ustar nicknick# intldir.m4 serial 2 (gettext-0.18) dnl Copyright (C) 2006, 2009-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl dnl This file can can be used in projects which are not available under dnl the GNU General Public License or the GNU Library General Public dnl License but which still want to provide support for the GNU gettext dnl functionality. dnl Please note that the actual code of the GNU gettext library is covered dnl by the GNU Library General Public License, and the rest of the GNU dnl gettext package package is covered by the GNU General Public License. dnl They are *not* in the public domain. AC_PREREQ([2.52]) dnl Tells the AM_GNU_GETTEXT macro to consider an intl/ directory. AC_DEFUN([AM_GNU_GETTEXT_INTL_SUBDIR], []) connman-ui-0_20150622+dfsg.orig/m4/po.m40000644000175000017500000004461612541725135015770 0ustar nicknick# po.m4 serial 17 (gettext-0.18) dnl Copyright (C) 1995-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl dnl This file can can be used in projects which are not available under dnl the GNU General Public License or the GNU Library General Public dnl License but which still want to provide support for the GNU gettext dnl functionality. dnl Please note that the actual code of the GNU gettext library is covered dnl by the GNU Library General Public License, and the rest of the GNU dnl gettext package package is covered by the GNU General Public License. dnl They are *not* in the public domain. dnl Authors: dnl Ulrich Drepper , 1995-2000. dnl Bruno Haible , 2000-2003. AC_PREREQ([2.50]) dnl Checks for all prerequisites of the po subdirectory. AC_DEFUN([AM_PO_SUBDIRS], [ AC_REQUIRE([AC_PROG_MAKE_SET])dnl AC_REQUIRE([AC_PROG_INSTALL])dnl AC_REQUIRE([AM_PROG_MKDIR_P])dnl defined by automake AC_REQUIRE([AM_NLS])dnl dnl Release version of the gettext macros. This is used to ensure that dnl the gettext macros and po/Makefile.in.in are in sync. AC_SUBST([GETTEXT_MACRO_VERSION], [0.18]) dnl Perform the following tests also if --disable-nls has been given, dnl because they are needed for "make dist" to work. dnl Search for GNU msgfmt in the PATH. dnl The first test excludes Solaris msgfmt and early GNU msgfmt versions. dnl The second test excludes FreeBSD msgfmt. AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt, [$ac_dir/$ac_word --statistics /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 && (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], :) AC_PATH_PROG([GMSGFMT], [gmsgfmt], [$MSGFMT]) dnl Test whether it is GNU msgfmt >= 0.15. changequote(,)dnl case `$MSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) MSGFMT_015=: ;; *) MSGFMT_015=$MSGFMT ;; esac changequote([,])dnl AC_SUBST([MSGFMT_015]) changequote(,)dnl case `$GMSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) GMSGFMT_015=: ;; *) GMSGFMT_015=$GMSGFMT ;; esac changequote([,])dnl AC_SUBST([GMSGFMT_015]) dnl Search for GNU xgettext 0.12 or newer in the PATH. dnl The first test excludes Solaris xgettext and early GNU xgettext versions. dnl The second test excludes FreeBSD xgettext. AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext, [$ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 && (if $ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], :) dnl Remove leftover from FreeBSD xgettext call. rm -f messages.po dnl Test whether it is GNU xgettext >= 0.15. changequote(,)dnl case `$XGETTEXT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) XGETTEXT_015=: ;; *) XGETTEXT_015=$XGETTEXT ;; esac changequote([,])dnl AC_SUBST([XGETTEXT_015]) dnl Search for GNU msgmerge 0.11 or newer in the PATH. AM_PATH_PROG_WITH_TEST(MSGMERGE, msgmerge, [$ac_dir/$ac_word --update -q /dev/null /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1], :) dnl Installation directories. dnl Autoconf >= 2.60 defines localedir. For older versions of autoconf, we dnl have to define it here, so that it can be used in po/Makefile. test -n "$localedir" || localedir='${datadir}/locale' AC_SUBST([localedir]) dnl Support for AM_XGETTEXT_OPTION. test -n "${XGETTEXT_EXTRA_OPTIONS+set}" || XGETTEXT_EXTRA_OPTIONS= AC_SUBST([XGETTEXT_EXTRA_OPTIONS]) AC_CONFIG_COMMANDS([po-directories], [[ for ac_file in $CONFIG_FILES; do # Support "outfile[:infile[:infile...]]" case "$ac_file" in *:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; esac # PO directories have a Makefile.in generated from Makefile.in.in. case "$ac_file" in */Makefile.in) # Adjust a relative srcdir. ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` ac_dir_suffix="/`echo "$ac_dir"|sed 's%^\./%%'`" ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` # In autoconf-2.13 it is called $ac_given_srcdir. # In autoconf-2.50 it is called $srcdir. test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" case "$ac_given_srcdir" in .) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;; /*) top_srcdir="$ac_given_srcdir" ;; *) top_srcdir="$ac_dots$ac_given_srcdir" ;; esac # Treat a directory as a PO directory if and only if it has a # POTFILES.in file. This allows packages to have multiple PO # directories under different names or in different locations. if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then rm -f "$ac_dir/POTFILES" test -n "$as_me" && echo "$as_me: creating $ac_dir/POTFILES" || echo "creating $ac_dir/POTFILES" cat "$ac_given_srcdir/$ac_dir/POTFILES.in" | sed -e "/^#/d" -e "/^[ ]*\$/d" -e "s,.*, $top_srcdir/& \\\\," | sed -e "\$s/\(.*\) \\\\/\1/" > "$ac_dir/POTFILES" POMAKEFILEDEPS="POTFILES.in" # ALL_LINGUAS, POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES depend # on $ac_dir but don't depend on user-specified configuration # parameters. if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then # The LINGUAS file contains the set of available languages. if test -n "$OBSOLETE_ALL_LINGUAS"; then test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete" fi ALL_LINGUAS_=`sed -e "/^#/d" -e "s/#.*//" "$ac_given_srcdir/$ac_dir/LINGUAS"` # Hide the ALL_LINGUAS assigment from automake < 1.5. eval 'ALL_LINGUAS''=$ALL_LINGUAS_' POMAKEFILEDEPS="$POMAKEFILEDEPS LINGUAS" else # The set of available languages was given in configure.in. # Hide the ALL_LINGUAS assigment from automake < 1.5. eval 'ALL_LINGUAS''=$OBSOLETE_ALL_LINGUAS' fi # Compute POFILES # as $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).po) # Compute UPDATEPOFILES # as $(foreach lang, $(ALL_LINGUAS), $(lang).po-update) # Compute DUMMYPOFILES # as $(foreach lang, $(ALL_LINGUAS), $(lang).nop) # Compute GMOFILES # as $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).gmo) case "$ac_given_srcdir" in .) srcdirpre= ;; *) srcdirpre='$(srcdir)/' ;; esac POFILES= UPDATEPOFILES= DUMMYPOFILES= GMOFILES= for lang in $ALL_LINGUAS; do POFILES="$POFILES $srcdirpre$lang.po" UPDATEPOFILES="$UPDATEPOFILES $lang.po-update" DUMMYPOFILES="$DUMMYPOFILES $lang.nop" GMOFILES="$GMOFILES $srcdirpre$lang.gmo" done # CATALOGS depends on both $ac_dir and the user's LINGUAS # environment variable. INST_LINGUAS= if test -n "$ALL_LINGUAS"; then for presentlang in $ALL_LINGUAS; do useit=no if test "%UNSET%" != "$LINGUAS"; then desiredlanguages="$LINGUAS" else desiredlanguages="$ALL_LINGUAS" fi for desiredlang in $desiredlanguages; do # Use the presentlang catalog if desiredlang is # a. equal to presentlang, or # b. a variant of presentlang (because in this case, # presentlang can be used as a fallback for messages # which are not translated in the desiredlang catalog). case "$desiredlang" in "$presentlang"*) useit=yes;; esac done if test $useit = yes; then INST_LINGUAS="$INST_LINGUAS $presentlang" fi done fi CATALOGS= if test -n "$INST_LINGUAS"; then for lang in $INST_LINGUAS; do CATALOGS="$CATALOGS $lang.gmo" done fi test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile" sed -e "/^POTFILES =/r $ac_dir/POTFILES" -e "/^# Makevars/r $ac_given_srcdir/$ac_dir/Makevars" -e "s|@POFILES@|$POFILES|g" -e "s|@UPDATEPOFILES@|$UPDATEPOFILES|g" -e "s|@DUMMYPOFILES@|$DUMMYPOFILES|g" -e "s|@GMOFILES@|$GMOFILES|g" -e "s|@CATALOGS@|$CATALOGS|g" -e "s|@POMAKEFILEDEPS@|$POMAKEFILEDEPS|g" "$ac_dir/Makefile.in" > "$ac_dir/Makefile" for f in "$ac_given_srcdir/$ac_dir"/Rules-*; do if test -f "$f"; then case "$f" in *.orig | *.bak | *~) ;; *) cat "$f" >> "$ac_dir/Makefile" ;; esac fi done fi ;; esac done]], [# Capture the value of obsolete ALL_LINGUAS because we need it to compute # POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES, CATALOGS. But hide it # from automake < 1.5. eval 'OBSOLETE_ALL_LINGUAS''="$ALL_LINGUAS"' # Capture the value of LINGUAS because we need it to compute CATALOGS. LINGUAS="${LINGUAS-%UNSET%}" ]) ]) dnl Postprocesses a Makefile in a directory containing PO files. AC_DEFUN([AM_POSTPROCESS_PO_MAKEFILE], [ # When this code is run, in config.status, two variables have already been # set: # - OBSOLETE_ALL_LINGUAS is the value of LINGUAS set in configure.in, # - LINGUAS is the value of the environment variable LINGUAS at configure # time. changequote(,)dnl # Adjust a relative srcdir. ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` ac_dir_suffix="/`echo "$ac_dir"|sed 's%^\./%%'`" ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` # In autoconf-2.13 it is called $ac_given_srcdir. # In autoconf-2.50 it is called $srcdir. test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" case "$ac_given_srcdir" in .) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;; /*) top_srcdir="$ac_given_srcdir" ;; *) top_srcdir="$ac_dots$ac_given_srcdir" ;; esac # Find a way to echo strings without interpreting backslash. if test "X`(echo '\t') 2>/dev/null`" = 'X\t'; then gt_echo='echo' else if test "X`(printf '%s\n' '\t') 2>/dev/null`" = 'X\t'; then gt_echo='printf %s\n' else echo_func () { cat < "$ac_file.tmp" if grep -l '@TCLCATALOGS@' "$ac_file" > /dev/null; then # Add dependencies that cannot be formulated as a simple suffix rule. for lang in $ALL_LINGUAS; do frobbedlang=`echo $lang | sed -e 's/\..*$//' -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'` cat >> "$ac_file.tmp" < /dev/null; then # Add dependencies that cannot be formulated as a simple suffix rule. for lang in $ALL_LINGUAS; do frobbedlang=`echo $lang | sed -e 's/_/-/g' -e 's/^sr-CS/sr-SP/' -e 's/@latin$/-Latn/' -e 's/@cyrillic$/-Cyrl/' -e 's/^sr-SP$/sr-SP-Latn/' -e 's/^uz-UZ$/uz-UZ-Latn/'` cat >> "$ac_file.tmp" <> "$ac_file.tmp" < to define O_NOATIME and O_NOFOLLOW. AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) AC_CACHE_CHECK([for working fcntl.h], [gl_cv_header_working_fcntl_h], [AC_RUN_IFELSE( [AC_LANG_PROGRAM( [[#include #include #include #include #ifndef O_NOATIME #define O_NOATIME 0 #endif #ifndef O_NOFOLLOW #define O_NOFOLLOW 0 #endif static int const constants[] = { O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC, O_APPEND, O_NONBLOCK, O_SYNC, O_ACCMODE, O_RDONLY, O_RDWR, O_WRONLY }; ]], [[ int status = !constants; { static char const sym[] = "conftest.sym"; if (symlink (".", sym) != 0 || close (open (sym, O_RDONLY | O_NOFOLLOW)) == 0) status |= 32; unlink (sym); } { static char const file[] = "confdefs.h"; int fd = open (file, O_RDONLY | O_NOATIME); char c; struct stat st0, st1; if (fd < 0 || fstat (fd, &st0) != 0 || sleep (1) != 0 || read (fd, &c, 1) != 1 || close (fd) != 0 || stat (file, &st1) != 0 || st0.st_atime != st1.st_atime) status |= 64; } return status;]])], [gl_cv_header_working_fcntl_h=yes], [case $? in #( 32) gl_cv_header_working_fcntl_h='no (bad O_NOFOLLOW)';; #( 64) gl_cv_header_working_fcntl_h='no (bad O_NOATIME)';; #( 96) gl_cv_header_working_fcntl_h='no (bad O_NOATIME, O_NOFOLLOW)';; #( *) gl_cv_header_working_fcntl_h='no';; esac], [gl_cv_header_working_fcntl_h=cross-compiling])]) case $gl_cv_header_working_fcntl_h in #( *O_NOATIME* | no | cross-compiling) ac_val=0;; #( *) ac_val=1;; esac AC_DEFINE_UNQUOTED([HAVE_WORKING_O_NOATIME], [$ac_val], [Define to 1 if O_NOATIME works.]) case $gl_cv_header_working_fcntl_h in #( *O_NOFOLLOW* | no | cross-compiling) ac_val=0;; #( *) ac_val=1;; esac AC_DEFINE_UNQUOTED([HAVE_WORKING_O_NOFOLLOW], [$ac_val], [Define to 1 if O_NOFOLLOW works.]) ]) connman-ui-0_20150622+dfsg.orig/m4/inttypes-pri.m40000644000175000017500000000220112541725135020001 0ustar nicknick# inttypes-pri.m4 serial 6 (gettext-0.18) dnl Copyright (C) 1997-2002, 2006, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. AC_PREREQ([2.52]) # Define PRI_MACROS_BROKEN if exists and defines the PRI* # macros to non-string values. This is the case on AIX 4.3.3. AC_DEFUN([gt_INTTYPES_PRI], [ AC_CHECK_HEADERS([inttypes.h]) if test $ac_cv_header_inttypes_h = yes; then AC_CACHE_CHECK([whether the inttypes.h PRIxNN macros are broken], [gt_cv_inttypes_pri_broken], [ AC_TRY_COMPILE([#include #ifdef PRId32 char *p = PRId32; #endif ], [], [gt_cv_inttypes_pri_broken=no], [gt_cv_inttypes_pri_broken=yes]) ]) fi if test "$gt_cv_inttypes_pri_broken" = yes; then AC_DEFINE_UNQUOTED([PRI_MACROS_BROKEN], [1], [Define if exists and defines unusable PRI* macros.]) PRI_MACROS_BROKEN=1 else PRI_MACROS_BROKEN=0 fi AC_SUBST([PRI_MACROS_BROKEN]) ]) connman-ui-0_20150622+dfsg.orig/m4/visibility.m40000644000175000017500000000624612541725135017536 0ustar nicknick# visibility.m4 serial 3 (gettext-0.18) dnl Copyright (C) 2005, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. dnl Tests whether the compiler supports the command-line option dnl -fvisibility=hidden and the function and variable attributes dnl __attribute__((__visibility__("hidden"))) and dnl __attribute__((__visibility__("default"))). dnl Does *not* test for __visibility__("protected") - which has tricky dnl semantics (see the 'vismain' test in glibc) and does not exist e.g. on dnl MacOS X. dnl Does *not* test for __visibility__("internal") - which has processor dnl dependent semantics. dnl Does *not* test for #pragma GCC visibility push(hidden) - which is dnl "really only recommended for legacy code". dnl Set the variable CFLAG_VISIBILITY. dnl Defines and sets the variable HAVE_VISIBILITY. AC_DEFUN([gl_VISIBILITY], [ AC_REQUIRE([AC_PROG_CC]) CFLAG_VISIBILITY= HAVE_VISIBILITY=0 if test -n "$GCC"; then dnl First, check whether -Werror can be added to the command line, or dnl whether it leads to an error because of some other option that the dnl user has put into $CC $CFLAGS $CPPFLAGS. AC_MSG_CHECKING([whether the -Werror option is usable]) AC_CACHE_VAL([gl_cv_cc_vis_werror], [ gl_save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -Werror" AC_TRY_COMPILE([], [], [gl_cv_cc_vis_werror=yes], [gl_cv_cc_vis_werror=no]) CFLAGS="$gl_save_CFLAGS"]) AC_MSG_RESULT([$gl_cv_cc_vis_werror]) dnl Now check whether visibility declarations are supported. AC_MSG_CHECKING([for simple visibility declarations]) AC_CACHE_VAL([gl_cv_cc_visibility], [ gl_save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -fvisibility=hidden" dnl We use the option -Werror and a function dummyfunc, because on some dnl platforms (Cygwin 1.7) the use of -fvisibility triggers a warning dnl "visibility attribute not supported in this configuration; ignored" dnl at the first function definition in every compilation unit, and we dnl don't want to use the option in this case. if test $gl_cv_cc_vis_werror = yes; then CFLAGS="$CFLAGS -Werror" fi AC_TRY_COMPILE( [extern __attribute__((__visibility__("hidden"))) int hiddenvar; extern __attribute__((__visibility__("default"))) int exportedvar; extern __attribute__((__visibility__("hidden"))) int hiddenfunc (void); extern __attribute__((__visibility__("default"))) int exportedfunc (void); void dummyfunc (void) {}], [], [gl_cv_cc_visibility=yes], [gl_cv_cc_visibility=no]) CFLAGS="$gl_save_CFLAGS"]) AC_MSG_RESULT([$gl_cv_cc_visibility]) if test $gl_cv_cc_visibility = yes; then CFLAG_VISIBILITY="-fvisibility=hidden" HAVE_VISIBILITY=1 fi fi AC_SUBST([CFLAG_VISIBILITY]) AC_SUBST([HAVE_VISIBILITY]) AC_DEFINE_UNQUOTED([HAVE_VISIBILITY], [$HAVE_VISIBILITY], [Define to 1 or 0, depending whether the compiler supports simple visibility declarations.]) ]) connman-ui-0_20150622+dfsg.orig/m4/codeset.m40000644000175000017500000000141312541725135016764 0ustar nicknick# codeset.m4 serial 4 (gettext-0.18) dnl Copyright (C) 2000-2002, 2006, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. AC_DEFUN([AM_LANGINFO_CODESET], [ AC_CACHE_CHECK([for nl_langinfo and CODESET], [am_cv_langinfo_codeset], [AC_TRY_LINK([#include ], [char* cs = nl_langinfo(CODESET); return !cs;], [am_cv_langinfo_codeset=yes], [am_cv_langinfo_codeset=no]) ]) if test $am_cv_langinfo_codeset = yes; then AC_DEFINE([HAVE_LANGINFO_CODESET], [1], [Define if you have and nl_langinfo(CODESET).]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/uintmax_t.m40000644000175000017500000000213112541725135017344 0ustar nicknick# uintmax_t.m4 serial 12 dnl Copyright (C) 1997-2004, 2007-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Paul Eggert. AC_PREREQ([2.13]) # Define uintmax_t to 'unsigned long' or 'unsigned long long' # if it is not already defined in or . AC_DEFUN([gl_AC_TYPE_UINTMAX_T], [ AC_REQUIRE([gl_AC_HEADER_INTTYPES_H]) AC_REQUIRE([gl_AC_HEADER_STDINT_H]) if test $gl_cv_header_inttypes_h = no && test $gl_cv_header_stdint_h = no; then AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT]) test $ac_cv_type_unsigned_long_long_int = yes \ && ac_type='unsigned long long' \ || ac_type='unsigned long' AC_DEFINE_UNQUOTED([uintmax_t], [$ac_type], [Define to unsigned long or unsigned long long if and don't define.]) else AC_DEFINE([HAVE_UINTMAX_T], [1], [Define if you have the 'uintmax_t' type in or .]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/libtool.m40000644000175000017500000104554612541725135017022 0ustar nicknick# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- # # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, # 2006, 2007, 2008, 2009, 2010 Free Software Foundation, # Inc. # Written by Gordon Matzigkeit, 1996 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. m4_define([_LT_COPYING], [dnl # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, # 2006, 2007, 2008, 2009, 2010 Free Software Foundation, # Inc. # Written by Gordon Matzigkeit, 1996 # # This file is part of GNU Libtool. # # GNU Libtool is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of # the License, or (at your option) any later version. # # As a special exception to the GNU General Public License, # if you distribute this file as part of a program or library that # is built using GNU Libtool, you may include this file under the # same distribution terms that you use for the rest of that program. # # GNU Libtool is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with GNU Libtool; see the file COPYING. If not, a copy # can be downloaded from http://www.gnu.org/licenses/gpl.html, or # obtained by writing to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. ]) # serial 57 LT_INIT # LT_PREREQ(VERSION) # ------------------ # Complain and exit if this libtool version is less that VERSION. m4_defun([LT_PREREQ], [m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1, [m4_default([$3], [m4_fatal([Libtool version $1 or higher is required], 63)])], [$2])]) # _LT_CHECK_BUILDDIR # ------------------ # Complain if the absolute build directory name contains unusual characters m4_defun([_LT_CHECK_BUILDDIR], [case `pwd` in *\ * | *\ *) AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;; esac ]) # LT_INIT([OPTIONS]) # ------------------ AC_DEFUN([LT_INIT], [AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl AC_BEFORE([$0], [LT_LANG])dnl AC_BEFORE([$0], [LT_OUTPUT])dnl AC_BEFORE([$0], [LTDL_INIT])dnl m4_require([_LT_CHECK_BUILDDIR])dnl dnl Autoconf doesn't catch unexpanded LT_ macros by default: m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4 dnl unless we require an AC_DEFUNed macro: AC_REQUIRE([LTOPTIONS_VERSION])dnl AC_REQUIRE([LTSUGAR_VERSION])dnl AC_REQUIRE([LTVERSION_VERSION])dnl AC_REQUIRE([LTOBSOLETE_VERSION])dnl m4_require([_LT_PROG_LTMAIN])dnl _LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}]) dnl Parse OPTIONS _LT_SET_OPTIONS([$0], [$1]) # This can be used to rebuild libtool when needed LIBTOOL_DEPS="$ltmain" # Always use our own libtool. LIBTOOL='$(SHELL) $(top_builddir)/libtool' AC_SUBST(LIBTOOL)dnl _LT_SETUP # Only expand once: m4_define([LT_INIT]) ])# LT_INIT # Old names: AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT]) AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_PROG_LIBTOOL], []) dnl AC_DEFUN([AM_PROG_LIBTOOL], []) # _LT_CC_BASENAME(CC) # ------------------- # Calculate cc_basename. Skip known compiler wrappers and cross-prefix. m4_defun([_LT_CC_BASENAME], [for cc_temp in $1""; do case $cc_temp in compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; \-*) ;; *) break;; esac done cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` ]) # _LT_FILEUTILS_DEFAULTS # ---------------------- # It is okay to use these file commands and assume they have been set # sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'. m4_defun([_LT_FILEUTILS_DEFAULTS], [: ${CP="cp -f"} : ${MV="mv -f"} : ${RM="rm -f"} ])# _LT_FILEUTILS_DEFAULTS # _LT_SETUP # --------- m4_defun([_LT_SETUP], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl _LT_DECL([], [host_alias], [0], [The host system])dnl _LT_DECL([], [host], [0])dnl _LT_DECL([], [host_os], [0])dnl dnl _LT_DECL([], [build_alias], [0], [The build system])dnl _LT_DECL([], [build], [0])dnl _LT_DECL([], [build_os], [0])dnl dnl AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([LT_PATH_LD])dnl AC_REQUIRE([LT_PATH_NM])dnl dnl AC_REQUIRE([AC_PROG_LN_S])dnl test -z "$LN_S" && LN_S="ln -s" _LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl dnl AC_REQUIRE([LT_CMD_MAX_LEN])dnl _LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl _LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_CHECK_SHELL_FEATURES])dnl m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl m4_require([_LT_CMD_RELOAD])dnl m4_require([_LT_CHECK_MAGIC_METHOD])dnl m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl m4_require([_LT_CMD_OLD_ARCHIVE])dnl m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl m4_require([_LT_WITH_SYSROOT])dnl _LT_CONFIG_LIBTOOL_INIT([ # See if we are running on zsh, and set the options which allow our # commands through without removal of \ escapes INIT. if test -n "\${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi ]) if test -n "${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi _LT_CHECK_OBJDIR m4_require([_LT_TAG_COMPILER])dnl case $host_os in aix3*) # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test "X${COLLECT_NAMES+set}" != Xset; then COLLECT_NAMES= export COLLECT_NAMES fi ;; esac # Global variables: ofile=libtool can_build_shared=yes # All known linkers require a `.a' archive for static linking (except MSVC, # which needs '.lib'). libext=a with_gnu_ld="$lt_cv_prog_gnu_ld" old_CC="$CC" old_CFLAGS="$CFLAGS" # Set sane defaults for various variables test -z "$CC" && CC=cc test -z "$LTCC" && LTCC=$CC test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS test -z "$LD" && LD=ld test -z "$ac_objext" && ac_objext=o _LT_CC_BASENAME([$compiler]) # Only perform the check for file, if the check method requires it test -z "$MAGIC_CMD" && MAGIC_CMD=file case $deplibs_check_method in file_magic*) if test "$file_magic_cmd" = '$MAGIC_CMD'; then _LT_PATH_MAGIC fi ;; esac # Use C for the default configuration in the libtool script LT_SUPPORTED_TAG([CC]) _LT_LANG_C_CONFIG _LT_LANG_DEFAULT_CONFIG _LT_CONFIG_COMMANDS ])# _LT_SETUP # _LT_PREPARE_SED_QUOTE_VARS # -------------------------- # Define a few sed substitution that help us do robust quoting. m4_defun([_LT_PREPARE_SED_QUOTE_VARS], [# Backslashify metacharacters that are still active within # double-quoted strings. sed_quote_subst='s/\([["`$\\]]\)/\\\1/g' # Same as above, but do not quote variable references. double_quote_subst='s/\([["`\\]]\)/\\\1/g' # Sed substitution to delay expansion of an escaped shell variable in a # double_quote_subst'ed string. delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' # Sed substitution to delay expansion of an escaped single quote. delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' # Sed substitution to avoid accidental globbing in evaled expressions no_glob_subst='s/\*/\\\*/g' ]) # _LT_PROG_LTMAIN # --------------- # Note that this code is called both from `configure', and `config.status' # now that we use AC_CONFIG_COMMANDS to generate libtool. Notably, # `config.status' has no value for ac_aux_dir unless we are using Automake, # so we pass a copy along to make sure it has a sensible value anyway. m4_defun([_LT_PROG_LTMAIN], [m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl _LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir']) ltmain="$ac_aux_dir/ltmain.sh" ])# _LT_PROG_LTMAIN ## ------------------------------------- ## ## Accumulate code for creating libtool. ## ## ------------------------------------- ## # So that we can recreate a full libtool script including additional # tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS # in macros and then make a single call at the end using the `libtool' # label. # _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS]) # ---------------------------------------- # Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later. m4_define([_LT_CONFIG_LIBTOOL_INIT], [m4_ifval([$1], [m4_append([_LT_OUTPUT_LIBTOOL_INIT], [$1 ])])]) # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_INIT]) # _LT_CONFIG_LIBTOOL([COMMANDS]) # ------------------------------ # Register COMMANDS to be passed to AC_CONFIG_COMMANDS later. m4_define([_LT_CONFIG_LIBTOOL], [m4_ifval([$1], [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS], [$1 ])])]) # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS]) # _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS]) # ----------------------------------------------------- m4_defun([_LT_CONFIG_SAVE_COMMANDS], [_LT_CONFIG_LIBTOOL([$1]) _LT_CONFIG_LIBTOOL_INIT([$2]) ]) # _LT_FORMAT_COMMENT([COMMENT]) # ----------------------------- # Add leading comment marks to the start of each line, and a trailing # full-stop to the whole comment if one is not present already. m4_define([_LT_FORMAT_COMMENT], [m4_ifval([$1], [ m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])], [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.]) )]) ## ------------------------ ## ## FIXME: Eliminate VARNAME ## ## ------------------------ ## # _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?]) # ------------------------------------------------------------------- # CONFIGNAME is the name given to the value in the libtool script. # VARNAME is the (base) name used in the configure script. # VALUE may be 0, 1 or 2 for a computed quote escaped value based on # VARNAME. Any other value will be used directly. m4_define([_LT_DECL], [lt_if_append_uniq([lt_decl_varnames], [$2], [, ], [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name], [m4_ifval([$1], [$1], [$2])]) lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3]) m4_ifval([$4], [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])]) lt_dict_add_subkey([lt_decl_dict], [$2], [tagged?], [m4_ifval([$5], [yes], [no])])]) ]) # _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION]) # -------------------------------------------------------- m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])]) # lt_decl_tag_varnames([SEPARATOR], [VARNAME1...]) # ------------------------------------------------ m4_define([lt_decl_tag_varnames], [_lt_decl_filter([tagged?], [yes], $@)]) # _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..]) # --------------------------------------------------------- m4_define([_lt_decl_filter], [m4_case([$#], [0], [m4_fatal([$0: too few arguments: $#])], [1], [m4_fatal([$0: too few arguments: $#: $1])], [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)], [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)], [lt_dict_filter([lt_decl_dict], $@)])[]dnl ]) # lt_decl_quote_varnames([SEPARATOR], [VARNAME1...]) # -------------------------------------------------- m4_define([lt_decl_quote_varnames], [_lt_decl_filter([value], [1], $@)]) # lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...]) # --------------------------------------------------- m4_define([lt_decl_dquote_varnames], [_lt_decl_filter([value], [2], $@)]) # lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...]) # --------------------------------------------------- m4_define([lt_decl_varnames_tagged], [m4_assert([$# <= 2])dnl _$0(m4_quote(m4_default([$1], [[, ]])), m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]), m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))]) m4_define([_lt_decl_varnames_tagged], [m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])]) # lt_decl_all_varnames([SEPARATOR], [VARNAME1...]) # ------------------------------------------------ m4_define([lt_decl_all_varnames], [_$0(m4_quote(m4_default([$1], [[, ]])), m4_if([$2], [], m4_quote(lt_decl_varnames), m4_quote(m4_shift($@))))[]dnl ]) m4_define([_lt_decl_all_varnames], [lt_join($@, lt_decl_varnames_tagged([$1], lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl ]) # _LT_CONFIG_STATUS_DECLARE([VARNAME]) # ------------------------------------ # Quote a variable value, and forward it to `config.status' so that its # declaration there will have the same value as in `configure'. VARNAME # must have a single quote delimited value for this to work. m4_define([_LT_CONFIG_STATUS_DECLARE], [$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`']) # _LT_CONFIG_STATUS_DECLARATIONS # ------------------------------ # We delimit libtool config variables with single quotes, so when # we write them to config.status, we have to be sure to quote all # embedded single quotes properly. In configure, this macro expands # each variable declared with _LT_DECL (and _LT_TAGDECL) into: # # ='`$ECHO "$" | $SED "$delay_single_quote_subst"`' m4_defun([_LT_CONFIG_STATUS_DECLARATIONS], [m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames), [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])]) # _LT_LIBTOOL_TAGS # ---------------- # Output comment and list of tags supported by the script m4_defun([_LT_LIBTOOL_TAGS], [_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl available_tags="_LT_TAGS"dnl ]) # _LT_LIBTOOL_DECLARE(VARNAME, [TAG]) # ----------------------------------- # Extract the dictionary values for VARNAME (optionally with TAG) and # expand to a commented shell variable setting: # # # Some comment about what VAR is for. # visible_name=$lt_internal_name m4_define([_LT_LIBTOOL_DECLARE], [_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [description])))[]dnl m4_pushdef([_libtool_name], m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])), [0], [_libtool_name=[$]$1], [1], [_libtool_name=$lt_[]$1], [2], [_libtool_name=$lt_[]$1], [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl ]) # _LT_LIBTOOL_CONFIG_VARS # ----------------------- # Produce commented declarations of non-tagged libtool config variables # suitable for insertion in the LIBTOOL CONFIG section of the `libtool' # script. Tagged libtool config variables (even for the LIBTOOL CONFIG # section) are produced by _LT_LIBTOOL_TAG_VARS. m4_defun([_LT_LIBTOOL_CONFIG_VARS], [m4_foreach([_lt_var], m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)), [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])]) # _LT_LIBTOOL_TAG_VARS(TAG) # ------------------------- m4_define([_LT_LIBTOOL_TAG_VARS], [m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames), [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])]) # _LT_TAGVAR(VARNAME, [TAGNAME]) # ------------------------------ m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])]) # _LT_CONFIG_COMMANDS # ------------------- # Send accumulated output to $CONFIG_STATUS. Thanks to the lists of # variables for single and double quote escaping we saved from calls # to _LT_DECL, we can put quote escaped variables declarations # into `config.status', and then the shell code to quote escape them in # for loops in `config.status'. Finally, any additional code accumulated # from calls to _LT_CONFIG_LIBTOOL_INIT is expanded. m4_defun([_LT_CONFIG_COMMANDS], [AC_PROVIDE_IFELSE([LT_OUTPUT], dnl If the libtool generation code has been placed in $CONFIG_LT, dnl instead of duplicating it all over again into config.status, dnl then we will have config.status run $CONFIG_LT later, so it dnl needs to know what name is stored there: [AC_CONFIG_COMMANDS([libtool], [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])], dnl If the libtool generation code is destined for config.status, dnl expand the accumulated commands and init code now: [AC_CONFIG_COMMANDS([libtool], [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])]) ])#_LT_CONFIG_COMMANDS # Initialize. m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT], [ # The HP-UX ksh and POSIX shell print the target directory to stdout # if CDPATH is set. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH sed_quote_subst='$sed_quote_subst' double_quote_subst='$double_quote_subst' delay_variable_subst='$delay_variable_subst' _LT_CONFIG_STATUS_DECLARATIONS LTCC='$LTCC' LTCFLAGS='$LTCFLAGS' compiler='$compiler_DEFAULT' # A function that is used when there is no print builtin or printf. func_fallback_echo () { eval 'cat <<_LTECHO_EOF \$[]1 _LTECHO_EOF' } # Quote evaled strings. for var in lt_decl_all_varnames([[ \ ]], lt_decl_quote_varnames); do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[[\\\\\\\`\\"\\\$]]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done # Double-quote double-evaled strings. for var in lt_decl_all_varnames([[ \ ]], lt_decl_dquote_varnames); do case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in *[[\\\\\\\`\\"\\\$]]*) eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ;; *) eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" ;; esac done _LT_OUTPUT_LIBTOOL_INIT ]) # _LT_GENERATED_FILE_INIT(FILE, [COMMENT]) # ------------------------------------ # Generate a child script FILE with all initialization necessary to # reuse the environment learned by the parent script, and make the # file executable. If COMMENT is supplied, it is inserted after the # `#!' sequence but before initialization text begins. After this # macro, additional text can be appended to FILE to form the body of # the child script. The macro ends with non-zero status if the # file could not be fully written (such as if the disk is full). m4_ifdef([AS_INIT_GENERATED], [m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])], [m4_defun([_LT_GENERATED_FILE_INIT], [m4_require([AS_PREPARE])]dnl [m4_pushdef([AS_MESSAGE_LOG_FD])]dnl [lt_write_fail=0 cat >$1 <<_ASEOF || lt_write_fail=1 #! $SHELL # Generated by $as_me. $2 SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$1 <<\_ASEOF || lt_write_fail=1 AS_SHELL_SANITIZE _AS_PREPARE exec AS_MESSAGE_FD>&1 _ASEOF test $lt_write_fail = 0 && chmod +x $1[]dnl m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT # LT_OUTPUT # --------- # This macro allows early generation of the libtool script (before # AC_OUTPUT is called), incase it is used in configure for compilation # tests. AC_DEFUN([LT_OUTPUT], [: ${CONFIG_LT=./config.lt} AC_MSG_NOTICE([creating $CONFIG_LT]) _LT_GENERATED_FILE_INIT(["$CONFIG_LT"], [# Run this file to recreate a libtool stub with the current configuration.]) cat >>"$CONFIG_LT" <<\_LTEOF lt_cl_silent=false exec AS_MESSAGE_LOG_FD>>config.log { echo AS_BOX([Running $as_me.]) } >&AS_MESSAGE_LOG_FD lt_cl_help="\ \`$as_me' creates a local libtool stub from the current configuration, for use in further configure time tests before the real libtool is generated. Usage: $[0] [[OPTIONS]] -h, --help print this help, then exit -V, --version print version number, then exit -q, --quiet do not print progress messages -d, --debug don't remove temporary files Report bugs to ." lt_cl_version="\ m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) configured by $[0], generated by m4_PACKAGE_STRING. Copyright (C) 2010 Free Software Foundation, Inc. This config.lt script is free software; the Free Software Foundation gives unlimited permision to copy, distribute and modify it." while test $[#] != 0 do case $[1] in --version | --v* | -V ) echo "$lt_cl_version"; exit 0 ;; --help | --h* | -h ) echo "$lt_cl_help"; exit 0 ;; --debug | --d* | -d ) debug=: ;; --quiet | --q* | --silent | --s* | -q ) lt_cl_silent=: ;; -*) AC_MSG_ERROR([unrecognized option: $[1] Try \`$[0] --help' for more information.]) ;; *) AC_MSG_ERROR([unrecognized argument: $[1] Try \`$[0] --help' for more information.]) ;; esac shift done if $lt_cl_silent; then exec AS_MESSAGE_FD>/dev/null fi _LTEOF cat >>"$CONFIG_LT" <<_LTEOF _LT_OUTPUT_LIBTOOL_COMMANDS_INIT _LTEOF cat >>"$CONFIG_LT" <<\_LTEOF AC_MSG_NOTICE([creating $ofile]) _LT_OUTPUT_LIBTOOL_COMMANDS AS_EXIT(0) _LTEOF chmod +x "$CONFIG_LT" # configure is writing to config.log, but config.lt does its own redirection, # appending to config.log, which fails on DOS, as config.log is still kept # open by configure. Here we exec the FD to /dev/null, effectively closing # config.log, so it can be properly (re)opened and appended to by config.lt. lt_cl_success=: test "$silent" = yes && lt_config_lt_args="$lt_config_lt_args --quiet" exec AS_MESSAGE_LOG_FD>/dev/null $SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false exec AS_MESSAGE_LOG_FD>>config.log $lt_cl_success || AS_EXIT(1) ])# LT_OUTPUT # _LT_CONFIG(TAG) # --------------- # If TAG is the built-in tag, create an initial libtool script with a # default configuration from the untagged config vars. Otherwise add code # to config.status for appending the configuration named by TAG from the # matching tagged config vars. m4_defun([_LT_CONFIG], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl _LT_CONFIG_SAVE_COMMANDS([ m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl m4_if(_LT_TAG, [C], [ # See if we are running on zsh, and set the options which allow our # commands through without removal of \ escapes. if test -n "${ZSH_VERSION+set}" ; then setopt NO_GLOB_SUBST fi cfgfile="${ofile}T" trap "$RM \"$cfgfile\"; exit 1" 1 2 15 $RM "$cfgfile" cat <<_LT_EOF >> "$cfgfile" #! $SHELL # `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. # Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: # NOTE: Changes made to this file will be lost: look at ltmain.sh. # _LT_COPYING _LT_LIBTOOL_TAGS # ### BEGIN LIBTOOL CONFIG _LT_LIBTOOL_CONFIG_VARS _LT_LIBTOOL_TAG_VARS # ### END LIBTOOL CONFIG _LT_EOF case $host_os in aix3*) cat <<\_LT_EOF >> "$cfgfile" # AIX sometimes has problems with the GCC collect2 program. For some # reason, if we set the COLLECT_NAMES environment variable, the problems # vanish in a puff of smoke. if test "X${COLLECT_NAMES+set}" != Xset; then COLLECT_NAMES= export COLLECT_NAMES fi _LT_EOF ;; esac _LT_PROG_LTMAIN # We use sed instead of cat because bash on DJGPP gets confused if # if finds mixed CR/LF and LF-only lines. Since sed operates in # text mode, it properly converts lines to CR/LF. This bash problem # is reportedly fixed, but why not run on old versions too? sed '$q' "$ltmain" >> "$cfgfile" \ || (rm -f "$cfgfile"; exit 1) _LT_PROG_REPLACE_SHELLFNS mv -f "$cfgfile" "$ofile" || (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") chmod +x "$ofile" ], [cat <<_LT_EOF >> "$ofile" dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded dnl in a comment (ie after a #). # ### BEGIN LIBTOOL TAG CONFIG: $1 _LT_LIBTOOL_TAG_VARS(_LT_TAG) # ### END LIBTOOL TAG CONFIG: $1 _LT_EOF ])dnl /m4_if ], [m4_if([$1], [], [ PACKAGE='$PACKAGE' VERSION='$VERSION' TIMESTAMP='$TIMESTAMP' RM='$RM' ofile='$ofile'], []) ])dnl /_LT_CONFIG_SAVE_COMMANDS ])# _LT_CONFIG # LT_SUPPORTED_TAG(TAG) # --------------------- # Trace this macro to discover what tags are supported by the libtool # --tag option, using: # autoconf --trace 'LT_SUPPORTED_TAG:$1' AC_DEFUN([LT_SUPPORTED_TAG], []) # C support is built-in for now m4_define([_LT_LANG_C_enabled], []) m4_define([_LT_TAGS], []) # LT_LANG(LANG) # ------------- # Enable libtool support for the given language if not already enabled. AC_DEFUN([LT_LANG], [AC_BEFORE([$0], [LT_OUTPUT])dnl m4_case([$1], [C], [_LT_LANG(C)], [C++], [_LT_LANG(CXX)], [Java], [_LT_LANG(GCJ)], [Fortran 77], [_LT_LANG(F77)], [Fortran], [_LT_LANG(FC)], [Windows Resource], [_LT_LANG(RC)], [m4_ifdef([_LT_LANG_]$1[_CONFIG], [_LT_LANG($1)], [m4_fatal([$0: unsupported language: "$1"])])])dnl ])# LT_LANG # _LT_LANG(LANGNAME) # ------------------ m4_defun([_LT_LANG], [m4_ifdef([_LT_LANG_]$1[_enabled], [], [LT_SUPPORTED_TAG([$1])dnl m4_append([_LT_TAGS], [$1 ])dnl m4_define([_LT_LANG_]$1[_enabled], [])dnl _LT_LANG_$1_CONFIG($1)])dnl ])# _LT_LANG # _LT_LANG_DEFAULT_CONFIG # ----------------------- m4_defun([_LT_LANG_DEFAULT_CONFIG], [AC_PROVIDE_IFELSE([AC_PROG_CXX], [LT_LANG(CXX)], [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])]) AC_PROVIDE_IFELSE([AC_PROG_F77], [LT_LANG(F77)], [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])]) AC_PROVIDE_IFELSE([AC_PROG_FC], [LT_LANG(FC)], [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])]) dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal dnl pulling things in needlessly. AC_PROVIDE_IFELSE([AC_PROG_GCJ], [LT_LANG(GCJ)], [AC_PROVIDE_IFELSE([A][M_PROG_GCJ], [LT_LANG(GCJ)], [AC_PROVIDE_IFELSE([LT_PROG_GCJ], [LT_LANG(GCJ)], [m4_ifdef([AC_PROG_GCJ], [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])]) m4_ifdef([A][M_PROG_GCJ], [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])]) m4_ifdef([LT_PROG_GCJ], [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])]) AC_PROVIDE_IFELSE([LT_PROG_RC], [LT_LANG(RC)], [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])]) ])# _LT_LANG_DEFAULT_CONFIG # Obsolete macros: AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)]) AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)]) AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)]) AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)]) AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_CXX], []) dnl AC_DEFUN([AC_LIBTOOL_F77], []) dnl AC_DEFUN([AC_LIBTOOL_FC], []) dnl AC_DEFUN([AC_LIBTOOL_GCJ], []) dnl AC_DEFUN([AC_LIBTOOL_RC], []) # _LT_TAG_COMPILER # ---------------- m4_defun([_LT_TAG_COMPILER], [AC_REQUIRE([AC_PROG_CC])dnl _LT_DECL([LTCC], [CC], [1], [A C compiler])dnl _LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl _LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl _LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl # If no C compiler was specified, use CC. LTCC=${LTCC-"$CC"} # If no C compiler flags were specified, use CFLAGS. LTCFLAGS=${LTCFLAGS-"$CFLAGS"} # Allow CC to be a program name with arguments. compiler=$CC ])# _LT_TAG_COMPILER # _LT_COMPILER_BOILERPLATE # ------------------------ # Check for compiler boilerplate output or warnings with # the simple compiler test code. m4_defun([_LT_COMPILER_BOILERPLATE], [m4_require([_LT_DECL_SED])dnl ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" >conftest.$ac_ext eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err _lt_compiler_boilerplate=`cat conftest.err` $RM conftest* ])# _LT_COMPILER_BOILERPLATE # _LT_LINKER_BOILERPLATE # ---------------------- # Check for linker boilerplate output or warnings with # the simple link test code. m4_defun([_LT_LINKER_BOILERPLATE], [m4_require([_LT_DECL_SED])dnl ac_outfile=conftest.$ac_objext echo "$lt_simple_link_test_code" >conftest.$ac_ext eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err _lt_linker_boilerplate=`cat conftest.err` $RM -r conftest* ])# _LT_LINKER_BOILERPLATE # _LT_REQUIRED_DARWIN_CHECKS # ------------------------- m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ case $host_os in rhapsody* | darwin*) AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:]) AC_CHECK_TOOL([NMEDIT], [nmedit], [:]) AC_CHECK_TOOL([LIPO], [lipo], [:]) AC_CHECK_TOOL([OTOOL], [otool], [:]) AC_CHECK_TOOL([OTOOL64], [otool64], [:]) _LT_DECL([], [DSYMUTIL], [1], [Tool to manipulate archived DWARF debug symbol files on Mac OS X]) _LT_DECL([], [NMEDIT], [1], [Tool to change global to local symbols on Mac OS X]) _LT_DECL([], [LIPO], [1], [Tool to manipulate fat objects and archives on Mac OS X]) _LT_DECL([], [OTOOL], [1], [ldd/readelf like tool for Mach-O binaries on Mac OS X]) _LT_DECL([], [OTOOL64], [1], [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4]) AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod], [lt_cv_apple_cc_single_mod=no if test -z "${LT_MULTI_MODULE}"; then # By default we will add the -single_module flag. You can override # by either setting the environment variable LT_MULTI_MODULE # non-empty at configure time, or by adding -multi_module to the # link flags. rm -rf libconftest.dylib* echo "int foo(void){return 1;}" > conftest.c echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ -dynamiclib -Wl,-single_module conftest.c 2>conftest.err _lt_result=$? if test -f libconftest.dylib && test ! -s conftest.err && test $_lt_result = 0; then lt_cv_apple_cc_single_mod=yes else cat conftest.err >&AS_MESSAGE_LOG_FD fi rm -rf libconftest.dylib* rm -f conftest.* fi]) AC_CACHE_CHECK([for -exported_symbols_list linker flag], [lt_cv_ld_exported_symbols_list], [lt_cv_ld_exported_symbols_list=no save_LDFLAGS=$LDFLAGS echo "_main" > conftest.sym LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [lt_cv_ld_exported_symbols_list=yes], [lt_cv_ld_exported_symbols_list=no]) LDFLAGS="$save_LDFLAGS" ]) AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load], [lt_cv_ld_force_load=no cat > conftest.c << _LT_EOF int forced_loaded() { return 2;} _LT_EOF echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD cat > conftest.c << _LT_EOF int main() { return 0;} _LT_EOF echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err _lt_result=$? if test -f conftest && test ! -s conftest.err && test $_lt_result = 0 && $GREP forced_load conftest 2>&1 >/dev/null; then lt_cv_ld_force_load=yes else cat conftest.err >&AS_MESSAGE_LOG_FD fi rm -f conftest.err libconftest.a conftest conftest.c rm -rf conftest.dSYM ]) case $host_os in rhapsody* | darwin1.[[012]]) _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; darwin1.*) _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; darwin*) # darwin 5.x on # if running on 10.5 or later, the deployment target defaults # to the OS version, if on x86, and 10.4, the deployment # target defaults to 10.4. Don't you love it? case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in 10.0,*86*-darwin8*|10.0,*-darwin[[91]]*) _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; 10.[[012]]*) _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; 10.*) _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; esac ;; esac if test "$lt_cv_apple_cc_single_mod" = "yes"; then _lt_dar_single_mod='$single_module' fi if test "$lt_cv_ld_exported_symbols_list" = "yes"; then _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' else _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' fi if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then _lt_dsymutil='~$DSYMUTIL $lib || :' else _lt_dsymutil= fi ;; esac ]) # _LT_DARWIN_LINKER_FEATURES # -------------------------- # Checks for linker and compiler features on darwin m4_defun([_LT_DARWIN_LINKER_FEATURES], [ m4_require([_LT_REQUIRED_DARWIN_CHECKS]) _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported if test "$lt_cv_ld_force_load" = "yes"; then _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' else _LT_TAGVAR(whole_archive_flag_spec, $1)='' fi _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined" case $cc_basename in ifort*) _lt_dar_can_shared=yes ;; *) _lt_dar_can_shared=$GCC ;; esac if test "$_lt_dar_can_shared" = "yes"; then output_verbose_link_cmd=func_echo_all _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" m4_if([$1], [CXX], [ if test "$lt_cv_apple_cc_single_mod" != "yes"; then _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" fi ],[]) else _LT_TAGVAR(ld_shlibs, $1)=no fi ]) # _LT_SYS_MODULE_PATH_AIX([TAGNAME]) # ---------------------------------- # Links a minimal program and checks the executable # for the system default hardcoded library path. In most cases, # this is /usr/lib:/lib, but when the MPI compilers are used # the location of the communication and MPI libs are included too. # If we don't find anything, use the default library path according # to the aix ld manual. # Store the results from the different compilers for each TAGNAME. # Allow to override them for all tags through lt_cv_aix_libpath. m4_defun([_LT_SYS_MODULE_PATH_AIX], [m4_require([_LT_DECL_SED])dnl if test "${lt_cv_aix_libpath+set}" = set; then aix_libpath=$lt_cv_aix_libpath else AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])], [AC_LINK_IFELSE([AC_LANG_PROGRAM],[ lt_aix_libpath_sed='[ /Import File Strings/,/^$/ { /^0/ { s/^0 *\([^ ]*\) *$/\1/ p } }]' _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` # Check for a 64-bit object if we didn't find anything. if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` fi],[]) if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib" fi ]) aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1]) fi ])# _LT_SYS_MODULE_PATH_AIX # _LT_SHELL_INIT(ARG) # ------------------- m4_define([_LT_SHELL_INIT], [m4_divert_text([M4SH-INIT], [$1 ])])# _LT_SHELL_INIT # _LT_PROG_ECHO_BACKSLASH # ----------------------- # Find how we can fake an echo command that does not interpret backslash. # In particular, with Autoconf 2.60 or later we add some code to the start # of the generated configure script which will find a shell with a builtin # printf (which we can use as an echo command). m4_defun([_LT_PROG_ECHO_BACKSLASH], [ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO AC_MSG_CHECKING([how to print strings]) # Test print first, because it will be a builtin if present. if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then ECHO='print -r --' elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then ECHO='printf %s\n' else # Use this function as a fallback that always works. func_fallback_echo () { eval 'cat <<_LTECHO_EOF $[]1 _LTECHO_EOF' } ECHO='func_fallback_echo' fi # func_echo_all arg... # Invoke $ECHO with all args, space-separated. func_echo_all () { $ECHO "$*" } case "$ECHO" in printf*) AC_MSG_RESULT([printf]) ;; print*) AC_MSG_RESULT([print -r]) ;; *) AC_MSG_RESULT([cat]) ;; esac m4_ifdef([_AS_DETECT_SUGGESTED], [_AS_DETECT_SUGGESTED([ test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || ( ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO PATH=/empty FPATH=/empty; export PATH FPATH test "X`printf %s $ECHO`" = "X$ECHO" \ || test "X`print -r -- $ECHO`" = "X$ECHO" )])]) _LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts]) _LT_DECL([], [ECHO], [1], [An echo program that protects backslashes]) ])# _LT_PROG_ECHO_BACKSLASH # _LT_WITH_SYSROOT # ---------------- AC_DEFUN([_LT_WITH_SYSROOT], [AC_MSG_CHECKING([for sysroot]) AC_ARG_WITH([sysroot], [ --with-sysroot[=DIR] Search for dependent libraries within DIR (or the compiler's sysroot if not specified).], [], [with_sysroot=no]) dnl lt_sysroot will always be passed unquoted. We quote it here dnl in case the user passed a directory name. lt_sysroot= case ${with_sysroot} in #( yes) if test "$GCC" = yes; then lt_sysroot=`$CC --print-sysroot 2>/dev/null` fi ;; #( /*) lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` ;; #( no|'') ;; #( *) AC_MSG_RESULT([${with_sysroot}]) AC_MSG_ERROR([The sysroot must be an absolute path.]) ;; esac AC_MSG_RESULT([${lt_sysroot:-no}]) _LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl [dependent libraries, and in which our libraries should be installed.])]) # _LT_ENABLE_LOCK # --------------- m4_defun([_LT_ENABLE_LOCK], [AC_ARG_ENABLE([libtool-lock], [AS_HELP_STRING([--disable-libtool-lock], [avoid locking (might break parallel builds)])]) test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes # Some flags need to be propagated to the compiler or linker for good # libtool support. case $host in ia64-*-hpux*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.$ac_objext` in *ELF-32*) HPUX_IA64_MODE="32" ;; *ELF-64*) HPUX_IA64_MODE="64" ;; esac fi rm -rf conftest* ;; *-*-irix6*) # Find out which ABI we are using. echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then if test "$lt_cv_prog_gnu_ld" = yes; then case `/usr/bin/file conftest.$ac_objext` in *32-bit*) LD="${LD-ld} -melf32bsmip" ;; *N32*) LD="${LD-ld} -melf32bmipn32" ;; *64-bit*) LD="${LD-ld} -melf64bmip" ;; esac else case `/usr/bin/file conftest.$ac_objext` in *32-bit*) LD="${LD-ld} -32" ;; *N32*) LD="${LD-ld} -n32" ;; *64-bit*) LD="${LD-ld} -64" ;; esac fi fi rm -rf conftest* ;; x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \ s390*-*linux*|s390*-*tpf*|sparc*-*linux*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.o` in *32-bit*) case $host in x86_64-*kfreebsd*-gnu) LD="${LD-ld} -m elf_i386_fbsd" ;; x86_64-*linux*) LD="${LD-ld} -m elf_i386" ;; ppc64-*linux*|powerpc64-*linux*) LD="${LD-ld} -m elf32ppclinux" ;; s390x-*linux*) LD="${LD-ld} -m elf_s390" ;; sparc64-*linux*) LD="${LD-ld} -m elf32_sparc" ;; esac ;; *64-bit*) case $host in x86_64-*kfreebsd*-gnu) LD="${LD-ld} -m elf_x86_64_fbsd" ;; x86_64-*linux*) LD="${LD-ld} -m elf_x86_64" ;; ppc*-*linux*|powerpc*-*linux*) LD="${LD-ld} -m elf64ppc" ;; s390*-*linux*|s390*-*tpf*) LD="${LD-ld} -m elf64_s390" ;; sparc*-*linux*) LD="${LD-ld} -m elf64_sparc" ;; esac ;; esac fi rm -rf conftest* ;; *-*-sco3.2v5*) # On SCO OpenServer 5, we need -belf to get full-featured binaries. SAVE_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -belf" AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, [AC_LANG_PUSH(C) AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) AC_LANG_POP]) if test x"$lt_cv_cc_needs_belf" != x"yes"; then # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf CFLAGS="$SAVE_CFLAGS" fi ;; sparc*-*solaris*) # Find out which ABI we are using. echo 'int i;' > conftest.$ac_ext if AC_TRY_EVAL(ac_compile); then case `/usr/bin/file conftest.o` in *64-bit*) case $lt_cv_prog_gnu_ld in yes*) LD="${LD-ld} -m elf64_sparc" ;; *) if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then LD="${LD-ld} -64" fi ;; esac ;; esac fi rm -rf conftest* ;; esac need_locks="$enable_libtool_lock" ])# _LT_ENABLE_LOCK # _LT_PROG_AR # ----------- m4_defun([_LT_PROG_AR], [AC_CHECK_TOOLS(AR, [ar], false) : ${AR=ar} : ${AR_FLAGS=cru} _LT_DECL([], [AR], [1], [The archiver]) _LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive]) AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], [lt_cv_ar_at_file=no AC_COMPILE_IFELSE([AC_LANG_PROGRAM], [echo conftest.$ac_objext > conftest.lst lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD' AC_TRY_EVAL([lt_ar_try]) if test "$ac_status" -eq 0; then # Ensure the archiver fails upon bogus file names. rm -f conftest.$ac_objext libconftest.a AC_TRY_EVAL([lt_ar_try]) if test "$ac_status" -ne 0; then lt_cv_ar_at_file=@ fi fi rm -f conftest.* libconftest.a ]) ]) if test "x$lt_cv_ar_at_file" = xno; then archiver_list_spec= else archiver_list_spec=$lt_cv_ar_at_file fi _LT_DECL([], [archiver_list_spec], [1], [How to feed a file listing to the archiver]) ])# _LT_PROG_AR # _LT_CMD_OLD_ARCHIVE # ------------------- m4_defun([_LT_CMD_OLD_ARCHIVE], [_LT_PROG_AR AC_CHECK_TOOL(STRIP, strip, :) test -z "$STRIP" && STRIP=: _LT_DECL([], [STRIP], [1], [A symbol stripping program]) AC_CHECK_TOOL(RANLIB, ranlib, :) test -z "$RANLIB" && RANLIB=: _LT_DECL([], [RANLIB], [1], [Commands used to install an old-style archive]) # Determine commands to create old-style static archives. old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' old_postinstall_cmds='chmod 644 $oldlib' old_postuninstall_cmds= if test -n "$RANLIB"; then case $host_os in openbsd*) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib" ;; *) old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib" ;; esac old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib" fi case $host_os in darwin*) lock_old_archive_extraction=yes ;; *) lock_old_archive_extraction=no ;; esac _LT_DECL([], [old_postinstall_cmds], [2]) _LT_DECL([], [old_postuninstall_cmds], [2]) _LT_TAGDECL([], [old_archive_cmds], [2], [Commands used to build an old-style archive]) _LT_DECL([], [lock_old_archive_extraction], [0], [Whether to use a lock for old archive extraction]) ])# _LT_CMD_OLD_ARCHIVE # _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, # [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE]) # ---------------------------------------------------------------- # Check whether the given compiler option works AC_DEFUN([_LT_COMPILER_OPTION], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_SED])dnl AC_CACHE_CHECK([$1], [$2], [$2=no m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="$3" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. # The option is referenced via a variable to avoid confusing sed. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) (eval "$lt_compile" 2>conftest.err) ac_status=$? cat conftest.err >&AS_MESSAGE_LOG_FD echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD if (exit $ac_status) && test -s "$ac_outfile"; then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings other than the usual output. $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then $2=yes fi fi $RM conftest* ]) if test x"[$]$2" = xyes; then m4_if([$5], , :, [$5]) else m4_if([$6], , :, [$6]) fi ])# _LT_COMPILER_OPTION # Old name: AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], []) # _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, # [ACTION-SUCCESS], [ACTION-FAILURE]) # ---------------------------------------------------- # Check whether the given linker option works AC_DEFUN([_LT_LINKER_OPTION], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_SED])dnl AC_CACHE_CHECK([$1], [$2], [$2=no save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS $3" echo "$lt_simple_link_test_code" > conftest.$ac_ext if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then # The linker can only warn and ignore the option if not recognized # So say no if there are warnings if test -s conftest.err; then # Append any errors to the config.log. cat conftest.err 1>&AS_MESSAGE_LOG_FD $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 if diff conftest.exp conftest.er2 >/dev/null; then $2=yes fi else $2=yes fi fi $RM -r conftest* LDFLAGS="$save_LDFLAGS" ]) if test x"[$]$2" = xyes; then m4_if([$4], , :, [$4]) else m4_if([$5], , :, [$5]) fi ])# _LT_LINKER_OPTION # Old name: AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], []) # LT_CMD_MAX_LEN #--------------- AC_DEFUN([LT_CMD_MAX_LEN], [AC_REQUIRE([AC_CANONICAL_HOST])dnl # find the maximum length of command line arguments AC_MSG_CHECKING([the maximum length of command line arguments]) AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl i=0 teststring="ABCD" case $build_os in msdosdjgpp*) # On DJGPP, this test can blow up pretty badly due to problems in libc # (any single argument exceeding 2000 bytes causes a buffer overrun # during glob expansion). Even if it were fixed, the result of this # check would be larger than it should be. lt_cv_sys_max_cmd_len=12288; # 12K is about right ;; gnu*) # Under GNU Hurd, this test is not required because there is # no limit to the length of command line arguments. # Libtool will interpret -1 as no limit whatsoever lt_cv_sys_max_cmd_len=-1; ;; cygwin* | mingw* | cegcc*) # On Win9x/ME, this test blows up -- it succeeds, but takes # about 5 minutes as the teststring grows exponentially. # Worse, since 9x/ME are not pre-emptively multitasking, # you end up with a "frozen" computer, even though with patience # the test eventually succeeds (with a max line length of 256k). # Instead, let's just punt: use the minimum linelength reported by # all of the supported platforms: 8192 (on NT/2K/XP). lt_cv_sys_max_cmd_len=8192; ;; mint*) # On MiNT this can take a long time and run out of memory. lt_cv_sys_max_cmd_len=8192; ;; amigaos*) # On AmigaOS with pdksh, this test takes hours, literally. # So we just punt and use a minimum line length of 8192. lt_cv_sys_max_cmd_len=8192; ;; netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) # This has been around since 386BSD, at least. Likely further. if test -x /sbin/sysctl; then lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` elif test -x /usr/sbin/sysctl; then lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` else lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs fi # And add a safety zone lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` ;; interix*) # We know the value 262144 and hardcode it with a safety zone (like BSD) lt_cv_sys_max_cmd_len=196608 ;; osf*) # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not # nice to cause kernel panics so lets avoid the loop below. # First set a reasonable default. lt_cv_sys_max_cmd_len=16384 # if test -x /sbin/sysconfig; then case `/sbin/sysconfig -q proc exec_disable_arg_limit` in *1*) lt_cv_sys_max_cmd_len=-1 ;; esac fi ;; sco3.2v5*) lt_cv_sys_max_cmd_len=102400 ;; sysv5* | sco5v6* | sysv4.2uw2*) kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` if test -n "$kargmax"; then lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ ]]//'` else lt_cv_sys_max_cmd_len=32768 fi ;; *) lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` if test -n "$lt_cv_sys_max_cmd_len"; then lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` else # Make teststring a little bigger before we do anything with it. # a 1K string should be a reasonable start. for i in 1 2 3 4 5 6 7 8 ; do teststring=$teststring$teststring done SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} # If test is not a shell built-in, we'll probably end up computing a # maximum length that is only half of the actual maximum length, but # we can't tell. while { test "X"`func_fallback_echo "$teststring$teststring" 2>/dev/null` \ = "X$teststring$teststring"; } >/dev/null 2>&1 && test $i != 17 # 1/2 MB should be enough do i=`expr $i + 1` teststring=$teststring$teststring done # Only check the string length outside the loop. lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` teststring= # Add a significant safety factor because C++ compilers can tack on # massive amounts of additional arguments before passing them to the # linker. It appears as though 1/2 is a usable value. lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` fi ;; esac ]) if test -n $lt_cv_sys_max_cmd_len ; then AC_MSG_RESULT($lt_cv_sys_max_cmd_len) else AC_MSG_RESULT(none) fi max_cmd_len=$lt_cv_sys_max_cmd_len _LT_DECL([], [max_cmd_len], [0], [What is the maximum length of a command?]) ])# LT_CMD_MAX_LEN # Old name: AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], []) # _LT_HEADER_DLFCN # ---------------- m4_defun([_LT_HEADER_DLFCN], [AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl ])# _LT_HEADER_DLFCN # _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE, # ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING) # ---------------------------------------------------------------- m4_defun([_LT_TRY_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl if test "$cross_compiling" = yes; then : [$4] else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF [#line $LINENO "configure" #include "confdefs.h" #if HAVE_DLFCN_H #include #endif #include #ifdef RTLD_GLOBAL # define LT_DLGLOBAL RTLD_GLOBAL #else # ifdef DL_GLOBAL # define LT_DLGLOBAL DL_GLOBAL # else # define LT_DLGLOBAL 0 # endif #endif /* We may have to define LT_DLLAZY_OR_NOW in the command line if we find out it does not work in some platform. */ #ifndef LT_DLLAZY_OR_NOW # ifdef RTLD_LAZY # define LT_DLLAZY_OR_NOW RTLD_LAZY # else # ifdef DL_LAZY # define LT_DLLAZY_OR_NOW DL_LAZY # else # ifdef RTLD_NOW # define LT_DLLAZY_OR_NOW RTLD_NOW # else # ifdef DL_NOW # define LT_DLLAZY_OR_NOW DL_NOW # else # define LT_DLLAZY_OR_NOW 0 # endif # endif # endif # endif #endif /* When -fvisbility=hidden is used, assume the code has been annotated correspondingly for the symbols needed. */ #if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) int fnord () __attribute__((visibility("default"))); #endif int fnord () { return 42; } int main () { void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); int status = $lt_dlunknown; if (self) { if (dlsym (self,"fnord")) status = $lt_dlno_uscore; else { if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; else puts (dlerror ()); } /* dlclose (self); */ } else puts (dlerror ()); return status; }] _LT_EOF if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null lt_status=$? case x$lt_status in x$lt_dlno_uscore) $1 ;; x$lt_dlneed_uscore) $2 ;; x$lt_dlunknown|x*) $3 ;; esac else : # compilation failed $3 fi fi rm -fr conftest* ])# _LT_TRY_DLOPEN_SELF # LT_SYS_DLOPEN_SELF # ------------------ AC_DEFUN([LT_SYS_DLOPEN_SELF], [m4_require([_LT_HEADER_DLFCN])dnl if test "x$enable_dlopen" != xyes; then enable_dlopen=unknown enable_dlopen_self=unknown enable_dlopen_self_static=unknown else lt_cv_dlopen=no lt_cv_dlopen_libs= case $host_os in beos*) lt_cv_dlopen="load_add_on" lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ;; mingw* | pw32* | cegcc*) lt_cv_dlopen="LoadLibrary" lt_cv_dlopen_libs= ;; cygwin*) lt_cv_dlopen="dlopen" lt_cv_dlopen_libs= ;; darwin*) # if libdl is installed we need to link against it AC_CHECK_LIB([dl], [dlopen], [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[ lt_cv_dlopen="dyld" lt_cv_dlopen_libs= lt_cv_dlopen_self=yes ]) ;; *) AC_CHECK_FUNC([shl_load], [lt_cv_dlopen="shl_load"], [AC_CHECK_LIB([dld], [shl_load], [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"], [AC_CHECK_FUNC([dlopen], [lt_cv_dlopen="dlopen"], [AC_CHECK_LIB([dl], [dlopen], [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], [AC_CHECK_LIB([svld], [dlopen], [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], [AC_CHECK_LIB([dld], [dld_link], [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"]) ]) ]) ]) ]) ]) ;; esac if test "x$lt_cv_dlopen" != xno; then enable_dlopen=yes else enable_dlopen=no fi case $lt_cv_dlopen in dlopen) save_CPPFLAGS="$CPPFLAGS" test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" save_LDFLAGS="$LDFLAGS" wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" save_LIBS="$LIBS" LIBS="$lt_cv_dlopen_libs $LIBS" AC_CACHE_CHECK([whether a program can dlopen itself], lt_cv_dlopen_self, [dnl _LT_TRY_DLOPEN_SELF( lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) ]) if test "x$lt_cv_dlopen_self" = xyes; then wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" AC_CACHE_CHECK([whether a statically linked program can dlopen itself], lt_cv_dlopen_self_static, [dnl _LT_TRY_DLOPEN_SELF( lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) ]) fi CPPFLAGS="$save_CPPFLAGS" LDFLAGS="$save_LDFLAGS" LIBS="$save_LIBS" ;; esac case $lt_cv_dlopen_self in yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; *) enable_dlopen_self=unknown ;; esac case $lt_cv_dlopen_self_static in yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; *) enable_dlopen_self_static=unknown ;; esac fi _LT_DECL([dlopen_support], [enable_dlopen], [0], [Whether dlopen is supported]) _LT_DECL([dlopen_self], [enable_dlopen_self], [0], [Whether dlopen of programs is supported]) _LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0], [Whether dlopen of statically linked programs is supported]) ])# LT_SYS_DLOPEN_SELF # Old name: AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], []) # _LT_COMPILER_C_O([TAGNAME]) # --------------------------- # Check to see if options -c and -o are simultaneously supported by compiler. # This macro does not hard code the compiler like AC_PROG_CC_C_O. m4_defun([_LT_COMPILER_C_O], [m4_require([_LT_DECL_SED])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_TAG_COMPILER])dnl AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext], [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)], [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest mkdir out echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="-o out/conftest2.$ac_objext" # Insert the option either (1) after the last *FLAGS variable, or # (2) before a word containing "conftest.", or (3) at the end. # Note that $ac_compile itself does not contain backslashes and begins # with a dollar sign (not a hyphen), so the echo should work correctly. lt_compile=`echo "$ac_compile" | $SED \ -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ -e 's:$: $lt_compiler_flag:'` (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) (eval "$lt_compile" 2>out/conftest.err) ac_status=$? cat out/conftest.err >&AS_MESSAGE_LOG_FD echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD if (exit $ac_status) && test -s out/conftest2.$ac_objext then # The compiler can only warn and ignore the option if not recognized # So say no if there are warnings $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes fi fi chmod u+w . 2>&AS_MESSAGE_LOG_FD $RM conftest* # SGI C++ compiler will create directory out/ii_files/ for # template instantiation test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files $RM out/* && rmdir out cd .. $RM -r conftest $RM conftest* ]) _LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1], [Does compiler simultaneously support -c and -o options?]) ])# _LT_COMPILER_C_O # _LT_COMPILER_FILE_LOCKS([TAGNAME]) # ---------------------------------- # Check to see if we can do hard links to lock some files if needed m4_defun([_LT_COMPILER_FILE_LOCKS], [m4_require([_LT_ENABLE_LOCK])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl _LT_COMPILER_C_O([$1]) hard_links="nottested" if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then # do not overwrite the value of need_locks provided by the user AC_MSG_CHECKING([if we can lock with hard links]) hard_links=yes $RM conftest* ln conftest.a conftest.b 2>/dev/null && hard_links=no touch conftest.a ln conftest.a conftest.b 2>&5 || hard_links=no ln conftest.a conftest.b 2>/dev/null && hard_links=no AC_MSG_RESULT([$hard_links]) if test "$hard_links" = no; then AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe]) need_locks=warn fi else need_locks=no fi _LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?]) ])# _LT_COMPILER_FILE_LOCKS # _LT_CHECK_OBJDIR # ---------------- m4_defun([_LT_CHECK_OBJDIR], [AC_CACHE_CHECK([for objdir], [lt_cv_objdir], [rm -f .libs 2>/dev/null mkdir .libs 2>/dev/null if test -d .libs; then lt_cv_objdir=.libs else # MS-DOS does not allow filenames that begin with a dot. lt_cv_objdir=_libs fi rmdir .libs 2>/dev/null]) objdir=$lt_cv_objdir _LT_DECL([], [objdir], [0], [The name of the directory that contains temporary libtool files])dnl m4_pattern_allow([LT_OBJDIR])dnl AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/", [Define to the sub-directory in which libtool stores uninstalled libraries.]) ])# _LT_CHECK_OBJDIR # _LT_LINKER_HARDCODE_LIBPATH([TAGNAME]) # -------------------------------------- # Check hardcoding attributes. m4_defun([_LT_LINKER_HARDCODE_LIBPATH], [AC_MSG_CHECKING([how to hardcode library paths into programs]) _LT_TAGVAR(hardcode_action, $1)= if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" || test -n "$_LT_TAGVAR(runpath_var, $1)" || test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then # We can hardcode non-existent directories. if test "$_LT_TAGVAR(hardcode_direct, $1)" != no && # If the only mechanism to avoid hardcoding is shlibpath_var, we # have to relink, otherwise we might link with an installed library # when we should be linking with a yet-to-be-installed one ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no && test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then # Linking always hardcodes the temporary library directory. _LT_TAGVAR(hardcode_action, $1)=relink else # We can link without hardcoding, and we can hardcode nonexisting dirs. _LT_TAGVAR(hardcode_action, $1)=immediate fi else # We cannot hardcode anything, or else we can only hardcode existing # directories. _LT_TAGVAR(hardcode_action, $1)=unsupported fi AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)]) if test "$_LT_TAGVAR(hardcode_action, $1)" = relink || test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then # Fast installation is not supported enable_fast_install=no elif test "$shlibpath_overrides_runpath" = yes || test "$enable_shared" = no; then # Fast installation is not necessary enable_fast_install=needless fi _LT_TAGDECL([], [hardcode_action], [0], [How to hardcode a shared library path into an executable]) ])# _LT_LINKER_HARDCODE_LIBPATH # _LT_CMD_STRIPLIB # ---------------- m4_defun([_LT_CMD_STRIPLIB], [m4_require([_LT_DECL_EGREP]) striplib= old_striplib= AC_MSG_CHECKING([whether stripping libraries is possible]) if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" test -z "$striplib" && striplib="$STRIP --strip-unneeded" AC_MSG_RESULT([yes]) else # FIXME - insert some real tests, host_os isn't really good enough case $host_os in darwin*) if test -n "$STRIP" ; then striplib="$STRIP -x" old_striplib="$STRIP -S" AC_MSG_RESULT([yes]) else AC_MSG_RESULT([no]) fi ;; *) AC_MSG_RESULT([no]) ;; esac fi _LT_DECL([], [old_striplib], [1], [Commands to strip libraries]) _LT_DECL([], [striplib], [1]) ])# _LT_CMD_STRIPLIB # _LT_SYS_DYNAMIC_LINKER([TAG]) # ----------------------------- # PORTME Fill in your ld.so characteristics m4_defun([_LT_SYS_DYNAMIC_LINKER], [AC_REQUIRE([AC_CANONICAL_HOST])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_OBJDUMP])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_CHECK_SHELL_FEATURES])dnl AC_MSG_CHECKING([dynamic linker characteristics]) m4_if([$1], [], [ if test "$GCC" = yes; then case $host_os in darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; *) lt_awk_arg="/^libraries:/" ;; esac case $host_os in mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;; *) lt_sed_strip_eq="s,=/,/,g" ;; esac lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` case $lt_search_path_spec in *\;*) # if the path contains ";" then we assume it to be the separator # otherwise default to the standard path separator (i.e. ":") - it is # assumed that no part of a normal pathname contains ";" but that should # okay in the real world where ";" in dirpaths is itself problematic. lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` ;; *) lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` ;; esac # Ok, now we have the path, separated by spaces, we can step through it # and add multilib dir if necessary. lt_tmp_lt_search_path_spec= lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` for lt_sys_path in $lt_search_path_spec; do if test -d "$lt_sys_path/$lt_multi_os_dir"; then lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" else test -d "$lt_sys_path" && \ lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" fi done lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' BEGIN {RS=" "; FS="/|\n";} { lt_foo=""; lt_count=0; for (lt_i = NF; lt_i > 0; lt_i--) { if ($lt_i != "" && $lt_i != ".") { if ($lt_i == "..") { lt_count++; } else { if (lt_count == 0) { lt_foo="/" $lt_i lt_foo; } else { lt_count--; } } } } if (lt_foo != "") { lt_freq[[lt_foo]]++; } if (lt_freq[[lt_foo]] == 1) { print lt_foo; } }'` # AWK program above erroneously prepends '/' to C:/dos/paths # for these hosts. case $host_os in mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ $SED 's,/\([[A-Za-z]]:\),\1,g'` ;; esac sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` else sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" fi]) library_names_spec= libname_spec='lib$name' soname_spec= shrext_cmds=".so" postinstall_cmds= postuninstall_cmds= finish_cmds= finish_eval= shlibpath_var= shlibpath_overrides_runpath=unknown version_type=none dynamic_linker="$host_os ld.so" sys_lib_dlsearch_path_spec="/lib /usr/lib" need_lib_prefix=unknown hardcode_into_libs=no # when you set need_version to no, make sure it does not cause -set_version # flags to be left without arguments need_version=unknown case $host_os in aix3*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' shlibpath_var=LIBPATH # AIX 3 has no versioning support, so we append a major version to the name. soname_spec='${libname}${release}${shared_ext}$major' ;; aix[[4-9]]*) version_type=linux need_lib_prefix=no need_version=no hardcode_into_libs=yes if test "$host_cpu" = ia64; then # AIX 5 supports IA64 library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH else # With GCC up to 2.95.x, collect2 would create an import file # for dependence libraries. The import file would start with # the line `#! .'. This would cause the generated library to # depend on `.', always an invalid library. This was fixed in # development snapshots of GCC prior to 3.0. case $host_os in aix4 | aix4.[[01]] | aix4.[[01]].*) if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' echo ' yes ' echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then : else can_build_shared=no fi ;; esac # AIX (on Power*) has no versioning support, so currently we can not hardcode correct # soname into executable. Probably we can add versioning support to # collect2, so additional links can be useful in future. if test "$aix_use_runtimelinking" = yes; then # If using run time linking (on AIX 4.2 or later) use lib.so # instead of lib.a to let people know that these are not # typical AIX shared libraries. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' else # We preserve .a as extension for shared libraries through AIX4.2 # and later when we are not doing run time linking. library_names_spec='${libname}${release}.a $libname.a' soname_spec='${libname}${release}${shared_ext}$major' fi shlibpath_var=LIBPATH fi ;; amigaos*) case $host_cpu in powerpc) # Since July 2007 AmigaOS4 officially supports .so libraries. # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' ;; m68k) library_names_spec='$libname.ixlibrary $libname.a' # Create ${libname}_ixlibrary.a entries in /sys/libs. finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' ;; esac ;; beos*) library_names_spec='${libname}${shared_ext}' dynamic_linker="$host_os ld.so" shlibpath_var=LIBRARY_PATH ;; bsdi[[45]]*) version_type=linux need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" # the default ld.so.conf also contains /usr/contrib/lib and # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow # libtool to hard-code these into programs ;; cygwin* | mingw* | pw32* | cegcc*) version_type=windows shrext_cmds=".dll" need_version=no need_lib_prefix=no case $GCC,$cc_basename in yes,*) # gcc library_names_spec='$libname.dll.a' # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds='base_file=`basename \${file}`~ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname~ chmod a+x \$dldir/$dlname~ if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; fi' postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ dlpath=$dir/\$dldll~ $RM \$dlpath' shlibpath_overrides_runpath=yes case $host_os in cygwin*) # Cygwin DLLs use 'cyg' prefix rather than 'lib' soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' m4_if([$1], [],[ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"]) ;; mingw* | cegcc*) # MinGW DLLs use traditional 'lib' prefix soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' ;; pw32*) # pw32 DLLs use 'pw' prefix rather than 'lib' library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' ;; esac dynamic_linker='Win32 ld.exe' ;; *,cl*) # Native MSVC libname_spec='$name' soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' library_names_spec='${libname}.dll.lib' case $build_os in mingw*) sys_lib_search_path_spec= lt_save_ifs=$IFS IFS=';' for lt_path in $LIB do IFS=$lt_save_ifs # Let DOS variable expansion print the short 8.3 style file name. lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" done IFS=$lt_save_ifs # Convert to MSYS style. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'` ;; cygwin*) # Convert to unix form, then to dos form, then back to unix form # but this time dos style (no spaces!) so that the unix form looks # like /cygdrive/c/PROGRA~1:/cygdr... sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` ;; *) sys_lib_search_path_spec="$LIB" if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then # It is most probably a Windows format PATH. sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` else sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` fi # FIXME: find the short name or the path components, as spaces are # common. (e.g. "Program Files" -> "PROGRA~1") ;; esac # DLL is installed to $(libdir)/../bin by postinstall_cmds postinstall_cmds='base_file=`basename \${file}`~ dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ dldir=$destdir/`dirname \$dlpath`~ test -d \$dldir || mkdir -p \$dldir~ $install_prog $dir/$dlname \$dldir/$dlname' postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ dlpath=$dir/\$dldll~ $RM \$dlpath' shlibpath_overrides_runpath=yes dynamic_linker='Win32 link.exe' ;; *) # Assume MSVC wrapper library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib' dynamic_linker='Win32 ld.exe' ;; esac # FIXME: first we should search . and the directory the executable is in shlibpath_var=PATH ;; darwin* | rhapsody*) dynamic_linker="$host_os dyld" version_type=darwin need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' soname_spec='${libname}${release}${major}$shared_ext' shlibpath_overrides_runpath=yes shlibpath_var=DYLD_LIBRARY_PATH shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' m4_if([$1], [],[ sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"]) sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' ;; dgux*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH ;; freebsd1*) dynamic_linker=no ;; freebsd* | dragonfly*) # DragonFly does not have aout. When/if they implement a new # versioning mechanism, adjust this. if test -x /usr/bin/objformat; then objformat=`/usr/bin/objformat` else case $host_os in freebsd[[123]]*) objformat=aout ;; *) objformat=elf ;; esac fi # Handle Gentoo/FreeBSD as it was Linux case $host_vendor in gentoo) version_type=linux ;; *) version_type=freebsd-$objformat ;; esac case $version_type in freebsd-elf*) library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' need_version=no need_lib_prefix=no ;; freebsd-*) library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' need_version=yes ;; linux) library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' need_lib_prefix=no need_version=no ;; esac shlibpath_var=LD_LIBRARY_PATH case $host_os in freebsd2*) shlibpath_overrides_runpath=yes ;; freebsd3.[[01]]* | freebsdelf3.[[01]]*) shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \ freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1) shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; *) # from 4.6 on, and DragonFly shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; esac ;; gnu*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH hardcode_into_libs=yes ;; haiku*) version_type=linux need_lib_prefix=no need_version=no dynamic_linker="$host_os runtime_loader" library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LIBRARY_PATH shlibpath_overrides_runpath=yes sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' hardcode_into_libs=yes ;; hpux9* | hpux10* | hpux11*) # Give a soname corresponding to the major version so that dld.sl refuses to # link against other versions. version_type=sunos need_lib_prefix=no need_version=no case $host_cpu in ia64*) shrext_cmds='.so' hardcode_into_libs=yes dynamic_linker="$host_os dld.so" shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' if test "X$HPUX_IA64_MODE" = X32; then sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" else sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" fi sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; hppa*64*) shrext_cmds='.sl' hardcode_into_libs=yes dynamic_linker="$host_os dld.sl" shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec ;; *) shrext_cmds='.sl' dynamic_linker="$host_os dld.sl" shlibpath_var=SHLIB_PATH shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' ;; esac # HP-UX runs *really* slowly unless shared libraries are mode 555, ... postinstall_cmds='chmod 555 $lib' # or fails outright, so override atomically: install_override_mode=555 ;; interix[[3-9]]*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; irix5* | irix6* | nonstopux*) case $host_os in nonstopux*) version_type=nonstopux ;; *) if test "$lt_cv_prog_gnu_ld" = yes; then version_type=linux else version_type=irix fi ;; esac need_lib_prefix=no need_version=no soname_spec='${libname}${release}${shared_ext}$major' library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' case $host_os in irix5* | nonstopux*) libsuff= shlibsuff= ;; *) case $LD in # libtool.m4 will add one of these switches to LD *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= libmagic=32-bit;; *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 libmagic=N32;; *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 libmagic=64-bit;; *) libsuff= shlibsuff= libmagic=never-match;; esac ;; esac shlibpath_var=LD_LIBRARY${shlibsuff}_PATH shlibpath_overrides_runpath=no sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" hardcode_into_libs=yes ;; # No shared lib support for Linux oldld, aout, or coff. linux*oldld* | linux*aout* | linux*coff*) dynamic_linker=no ;; # This must be Linux ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no # Some binutils ld are patched to set DT_RUNPATH AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath], [lt_cv_shlibpath_overrides_runpath=no save_LDFLAGS=$LDFLAGS save_libdir=$libdir eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \ LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\"" AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null], [lt_cv_shlibpath_overrides_runpath=yes])]) LDFLAGS=$save_LDFLAGS libdir=$save_libdir ]) shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath # This implies no fast_install, which is unacceptable. # Some rework will be needed to allow for fast_install # before this can be enabled. hardcode_into_libs=yes # Append ld.so.conf contents to the search path if test -f /etc/ld.so.conf; then lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" fi # We used to test for /lib/ld.so.1 and disable shared libraries on # powerpc, because MkLinux only supported shared libraries with the # GNU dynamic linker. Since this was broken with cross compilers, # most powerpc-linux boxes support dynamic linking these days and # people can always --disable-shared, the test was removed, and we # assume the GNU/Linux dynamic linker is in use. dynamic_linker='GNU/Linux ld.so' ;; netbsd*) version_type=sunos need_lib_prefix=no need_version=no if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' dynamic_linker='NetBSD (a.out) ld.so' else library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' dynamic_linker='NetBSD ld.elf_so' fi shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes ;; newsos6) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes ;; *nto* | *qnx*) version_type=qnx need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes dynamic_linker='ldqnx.so' ;; openbsd*) version_type=sunos sys_lib_dlsearch_path_spec="/usr/lib" need_lib_prefix=no # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. case $host_os in openbsd3.3 | openbsd3.3.*) need_version=yes ;; *) need_version=no ;; esac library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' shlibpath_var=LD_LIBRARY_PATH if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then case $host_os in openbsd2.[[89]] | openbsd2.[[89]].*) shlibpath_overrides_runpath=no ;; *) shlibpath_overrides_runpath=yes ;; esac else shlibpath_overrides_runpath=yes fi ;; os2*) libname_spec='$name' shrext_cmds=".dll" need_lib_prefix=no library_names_spec='$libname${shared_ext} $libname.a' dynamic_linker='OS/2 ld.exe' shlibpath_var=LIBPATH ;; osf3* | osf4* | osf5*) version_type=osf need_lib_prefix=no need_version=no soname_spec='${libname}${release}${shared_ext}$major' library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" ;; rdos*) dynamic_linker=no ;; solaris*) version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes # ldd complains unless libraries are executable postinstall_cmds='chmod +x $lib' ;; sunos4*) version_type=sunos library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes if test "$with_gnu_ld" = yes; then need_lib_prefix=no fi need_version=yes ;; sysv4 | sysv4.3*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH case $host_vendor in sni) shlibpath_overrides_runpath=no need_lib_prefix=no runpath_var=LD_RUN_PATH ;; siemens) need_lib_prefix=no ;; motorola) need_lib_prefix=no need_version=no shlibpath_overrides_runpath=no sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' ;; esac ;; sysv4*MP*) if test -d /usr/nec ;then version_type=linux library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' soname_spec='$libname${shared_ext}.$major' shlibpath_var=LD_LIBRARY_PATH fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) version_type=freebsd-elf need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=yes hardcode_into_libs=yes if test "$with_gnu_ld" = yes; then sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' else sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' case $host_os in sco3.2v5*) sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" ;; esac fi sys_lib_dlsearch_path_spec='/usr/lib' ;; tpf*) # TPF is a cross-target only. Preferred cross-host = GNU/Linux. version_type=linux need_lib_prefix=no need_version=no library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' shlibpath_var=LD_LIBRARY_PATH shlibpath_overrides_runpath=no hardcode_into_libs=yes ;; uts4*) version_type=linux library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' soname_spec='${libname}${release}${shared_ext}$major' shlibpath_var=LD_LIBRARY_PATH ;; *) dynamic_linker=no ;; esac AC_MSG_RESULT([$dynamic_linker]) test "$dynamic_linker" = no && can_build_shared=no variables_saved_for_relink="PATH $shlibpath_var $runpath_var" if test "$GCC" = yes; then variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" fi if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" fi if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" fi _LT_DECL([], [variables_saved_for_relink], [1], [Variables whose values should be saved in libtool wrapper scripts and restored at link time]) _LT_DECL([], [need_lib_prefix], [0], [Do we need the "lib" prefix for modules?]) _LT_DECL([], [need_version], [0], [Do we need a version for libraries?]) _LT_DECL([], [version_type], [0], [Library versioning type]) _LT_DECL([], [runpath_var], [0], [Shared library runtime path variable]) _LT_DECL([], [shlibpath_var], [0],[Shared library path variable]) _LT_DECL([], [shlibpath_overrides_runpath], [0], [Is shlibpath searched before the hard-coded library search path?]) _LT_DECL([], [libname_spec], [1], [Format of library name prefix]) _LT_DECL([], [library_names_spec], [1], [[List of archive names. First name is the real one, the rest are links. The last name is the one that the linker finds with -lNAME]]) _LT_DECL([], [soname_spec], [1], [[The coded name of the library, if different from the real name]]) _LT_DECL([], [install_override_mode], [1], [Permission mode override for installation of shared libraries]) _LT_DECL([], [postinstall_cmds], [2], [Command to use after installation of a shared archive]) _LT_DECL([], [postuninstall_cmds], [2], [Command to use after uninstallation of a shared archive]) _LT_DECL([], [finish_cmds], [2], [Commands used to finish a libtool library installation in a directory]) _LT_DECL([], [finish_eval], [1], [[As "finish_cmds", except a single script fragment to be evaled but not shown]]) _LT_DECL([], [hardcode_into_libs], [0], [Whether we should hardcode library paths into libraries]) _LT_DECL([], [sys_lib_search_path_spec], [2], [Compile-time system search path for libraries]) _LT_DECL([], [sys_lib_dlsearch_path_spec], [2], [Run-time system search path for libraries]) ])# _LT_SYS_DYNAMIC_LINKER # _LT_PATH_TOOL_PREFIX(TOOL) # -------------------------- # find a file program which can recognize shared library AC_DEFUN([_LT_PATH_TOOL_PREFIX], [m4_require([_LT_DECL_EGREP])dnl AC_MSG_CHECKING([for $1]) AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, [case $MAGIC_CMD in [[\\/*] | ?:[\\/]*]) lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. ;; *) lt_save_MAGIC_CMD="$MAGIC_CMD" lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR dnl $ac_dummy forces splitting on constant user-supplied paths. dnl POSIX.2 word splitting is done only on the output of word expansions, dnl not every word. This closes a longstanding sh security hole. ac_dummy="m4_if([$2], , $PATH, [$2])" for ac_dir in $ac_dummy; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. if test -f $ac_dir/$1; then lt_cv_path_MAGIC_CMD="$ac_dir/$1" if test -n "$file_magic_test_file"; then case $deplibs_check_method in "file_magic "*) file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | $EGREP "$file_magic_regex" > /dev/null; then : else cat <<_LT_EOF 1>&2 *** Warning: the command libtool uses to detect shared libraries, *** $file_magic_cmd, produces output that libtool cannot recognize. *** The result is that libtool may fail to recognize shared libraries *** as such. This will affect the creation of libtool libraries that *** depend on shared libraries, but programs linked with such libtool *** libraries will work regardless of this problem. Nevertheless, you *** may want to report the problem to your system manager and/or to *** bug-libtool@gnu.org _LT_EOF fi ;; esac fi break fi done IFS="$lt_save_ifs" MAGIC_CMD="$lt_save_MAGIC_CMD" ;; esac]) MAGIC_CMD="$lt_cv_path_MAGIC_CMD" if test -n "$MAGIC_CMD"; then AC_MSG_RESULT($MAGIC_CMD) else AC_MSG_RESULT(no) fi _LT_DECL([], [MAGIC_CMD], [0], [Used to examine libraries when file_magic_cmd begins with "file"])dnl ])# _LT_PATH_TOOL_PREFIX # Old name: AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], []) # _LT_PATH_MAGIC # -------------- # find a file program which can recognize a shared library m4_defun([_LT_PATH_MAGIC], [_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) if test -z "$lt_cv_path_MAGIC_CMD"; then if test -n "$ac_tool_prefix"; then _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH) else MAGIC_CMD=: fi fi ])# _LT_PATH_MAGIC # LT_PATH_LD # ---------- # find the pathname to the GNU or non-GNU linker AC_DEFUN([LT_PATH_LD], [AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_PROG_ECHO_BACKSLASH])dnl AC_ARG_WITH([gnu-ld], [AS_HELP_STRING([--with-gnu-ld], [assume the C compiler uses GNU ld @<:@default=no@:>@])], [test "$withval" = no || with_gnu_ld=yes], [with_gnu_ld=no])dnl ac_prog=ld if test "$GCC" = yes; then # Check if gcc -print-prog-name=ld gives a path. AC_MSG_CHECKING([for ld used by $CC]) case $host in *-*-mingw*) # gcc leaves a trailing carriage return which upsets mingw ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; *) ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; esac case $ac_prog in # Accept absolute paths. [[\\/]]* | ?:[[\\/]]*) re_direlt='/[[^/]][[^/]]*/\.\./' # Canonicalize the pathname of ld ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` done test -z "$LD" && LD="$ac_prog" ;; "") # If it fails, then pretend we aren't using GCC. ac_prog=ld ;; *) # If it is relative, then search for the first ld in PATH. with_gnu_ld=unknown ;; esac elif test "$with_gnu_ld" = yes; then AC_MSG_CHECKING([for GNU ld]) else AC_MSG_CHECKING([for non-GNU ld]) fi AC_CACHE_VAL(lt_cv_path_LD, [if test -z "$LD"; then lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then lt_cv_path_LD="$ac_dir/$ac_prog" # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some variants of GNU ld only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case `"$lt_cv_path_LD" -v 2>&1 &1 /dev/null 2>&1; then lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' lt_cv_file_magic_cmd='func_win32_libid' else # Keep this pattern in sync with the one in func_win32_libid. lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' lt_cv_file_magic_cmd='$OBJDUMP -f' fi ;; cegcc*) # use the weaker test based on 'objdump'. See mingw*. lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' lt_cv_file_magic_cmd='$OBJDUMP -f' ;; darwin* | rhapsody*) lt_cv_deplibs_check_method=pass_all ;; freebsd* | dragonfly*) if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then case $host_cpu in i*86 ) # Not sure whether the presence of OpenBSD here was a mistake. # Let's accept both of them until this is cleared up. lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library' lt_cv_file_magic_cmd=/usr/bin/file lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` ;; esac else lt_cv_deplibs_check_method=pass_all fi ;; gnu*) lt_cv_deplibs_check_method=pass_all ;; haiku*) lt_cv_deplibs_check_method=pass_all ;; hpux10.20* | hpux11*) lt_cv_file_magic_cmd=/usr/bin/file case $host_cpu in ia64*) lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64' lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so ;; hppa*64*) [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'] lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl ;; *) lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library' lt_cv_file_magic_test_file=/usr/lib/libc.sl ;; esac ;; interix[[3-9]]*) # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$' ;; irix5* | irix6* | nonstopux*) case $LD in *-32|*"-32 ") libmagic=32-bit;; *-n32|*"-n32 ") libmagic=N32;; *-64|*"-64 ") libmagic=64-bit;; *) libmagic=never-match;; esac lt_cv_deplibs_check_method=pass_all ;; # This must be Linux ELF. linux* | k*bsd*-gnu | kopensolaris*-gnu) lt_cv_deplibs_check_method=pass_all ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' else lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$' fi ;; newos6*) lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)' lt_cv_file_magic_cmd=/usr/bin/file lt_cv_file_magic_test_file=/usr/lib/libnls.so ;; *nto* | *qnx*) lt_cv_deplibs_check_method=pass_all ;; openbsd*) if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$' else lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' fi ;; osf3* | osf4* | osf5*) lt_cv_deplibs_check_method=pass_all ;; rdos*) lt_cv_deplibs_check_method=pass_all ;; solaris*) lt_cv_deplibs_check_method=pass_all ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) lt_cv_deplibs_check_method=pass_all ;; sysv4 | sysv4.3*) case $host_vendor in motorola) lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]' lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` ;; ncr) lt_cv_deplibs_check_method=pass_all ;; sequent) lt_cv_file_magic_cmd='/bin/file' lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' ;; sni) lt_cv_file_magic_cmd='/bin/file' lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib" lt_cv_file_magic_test_file=/lib/libc.so ;; siemens) lt_cv_deplibs_check_method=pass_all ;; pc) lt_cv_deplibs_check_method=pass_all ;; esac ;; tpf*) lt_cv_deplibs_check_method=pass_all ;; esac ]) file_magic_glob= want_nocaseglob=no if test "$build" = "$host"; then case $host_os in mingw* | pw32*) if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then want_nocaseglob=yes else file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"` fi ;; esac fi file_magic_cmd=$lt_cv_file_magic_cmd deplibs_check_method=$lt_cv_deplibs_check_method test -z "$deplibs_check_method" && deplibs_check_method=unknown _LT_DECL([], [deplibs_check_method], [1], [Method to check whether dependent libraries are shared objects]) _LT_DECL([], [file_magic_cmd], [1], [Command to use when deplibs_check_method = "file_magic"]) _LT_DECL([], [file_magic_glob], [1], [How to find potential files when deplibs_check_method = "file_magic"]) _LT_DECL([], [want_nocaseglob], [1], [Find potential files using nocaseglob when deplibs_check_method = "file_magic"]) ])# _LT_CHECK_MAGIC_METHOD # LT_PATH_NM # ---------- # find the pathname to a BSD- or MS-compatible name lister AC_DEFUN([LT_PATH_NM], [AC_REQUIRE([AC_PROG_CC])dnl AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM, [if test -n "$NM"; then # Let the user override the test. lt_cv_path_NM="$NM" else lt_nm_to_check="${ac_tool_prefix}nm" if test -n "$ac_tool_prefix" && test "$build" = "$host"; then lt_nm_to_check="$lt_nm_to_check nm" fi for lt_tmp_nm in $lt_nm_to_check; do lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do IFS="$lt_save_ifs" test -z "$ac_dir" && ac_dir=. tmp_nm="$ac_dir/$lt_tmp_nm" if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then # Check to see if the nm accepts a BSD-compat flag. # Adding the `sed 1q' prevents false positives on HP-UX, which says: # nm: unknown option "B" ignored # Tru64's nm complains that /dev/null is an invalid object file case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in */dev/null* | *'Invalid file or object type'*) lt_cv_path_NM="$tmp_nm -B" break ;; *) case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in */dev/null*) lt_cv_path_NM="$tmp_nm -p" break ;; *) lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but continue # so that we can try to find one that supports BSD flags ;; esac ;; esac fi done IFS="$lt_save_ifs" done : ${lt_cv_path_NM=no} fi]) if test "$lt_cv_path_NM" != "no"; then NM="$lt_cv_path_NM" else # Didn't find any BSD compatible name lister, look for dumpbin. if test -n "$DUMPBIN"; then : # Let the user override the test. else AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in *COFF*) DUMPBIN="$DUMPBIN -symbols" ;; *) DUMPBIN=: ;; esac fi AC_SUBST([DUMPBIN]) if test "$DUMPBIN" != ":"; then NM="$DUMPBIN" fi fi test -z "$NM" && NM=nm AC_SUBST([NM]) _LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface], [lt_cv_nm_interface="BSD nm" echo "int some_variable = 0;" > conftest.$ac_ext (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD) (eval "$ac_compile" 2>conftest.err) cat conftest.err >&AS_MESSAGE_LOG_FD (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD) (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) cat conftest.err >&AS_MESSAGE_LOG_FD (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD) cat conftest.out >&AS_MESSAGE_LOG_FD if $GREP 'External.*some_variable' conftest.out > /dev/null; then lt_cv_nm_interface="MS dumpbin" fi rm -f conftest*]) ])# LT_PATH_NM # Old names: AU_ALIAS([AM_PROG_NM], [LT_PATH_NM]) AU_ALIAS([AC_PROG_NM], [LT_PATH_NM]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AM_PROG_NM], []) dnl AC_DEFUN([AC_PROG_NM], []) # _LT_CHECK_SHAREDLIB_FROM_LINKLIB # -------------------------------- # how to determine the name of the shared library # associated with a specific link library. # -- PORTME fill in with the dynamic library characteristics m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB], [m4_require([_LT_DECL_EGREP]) m4_require([_LT_DECL_OBJDUMP]) m4_require([_LT_DECL_DLLTOOL]) AC_CACHE_CHECK([how to associate runtime and link libraries], lt_cv_sharedlib_from_linklib_cmd, [lt_cv_sharedlib_from_linklib_cmd='unknown' case $host_os in cygwin* | mingw* | pw32* | cegcc*) # two different shell functions defined in ltmain.sh # decide which to use based on capabilities of $DLLTOOL case `$DLLTOOL --help 2>&1` in *--identify-strict*) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib ;; *) lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback ;; esac ;; *) # fallback: assume linklib IS sharedlib lt_cv_sharedlib_from_linklib_cmd="$ECHO" ;; esac ]) sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO _LT_DECL([], [sharedlib_from_linklib_cmd], [1], [Command to associate shared and link libraries]) ])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB # _LT_PATH_MANIFEST_TOOL # ---------------------- # locate the manifest tool m4_defun([_LT_PATH_MANIFEST_TOOL], [AC_CHECK_TOOL(MANIFEST_TOOL, mt, :) test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool], [lt_cv_path_mainfest_tool=no echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out cat conftest.err >&AS_MESSAGE_LOG_FD if $GREP 'Manifest Tool' conftest.out > /dev/null; then lt_cv_path_mainfest_tool=yes fi rm -f conftest*]) if test "x$lt_cv_path_mainfest_tool" != xyes; then MANIFEST_TOOL=: fi _LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl ])# _LT_PATH_MANIFEST_TOOL # LT_LIB_M # -------- # check for math library AC_DEFUN([LT_LIB_M], [AC_REQUIRE([AC_CANONICAL_HOST])dnl LIBM= case $host in *-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*) # These system don't have libm, or don't need it ;; *-ncr-sysv4.3*) AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw") AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") ;; *) AC_CHECK_LIB(m, cos, LIBM="-lm") ;; esac AC_SUBST([LIBM]) ])# LT_LIB_M # Old name: AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([AC_CHECK_LIBM], []) # _LT_COMPILER_NO_RTTI([TAGNAME]) # ------------------------------- m4_defun([_LT_COMPILER_NO_RTTI], [m4_require([_LT_TAG_COMPILER])dnl _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= if test "$GCC" = yes; then case $cc_basename in nvcc*) _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;; *) _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;; esac _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions], lt_cv_prog_compiler_rtti_exceptions, [-fno-rtti -fno-exceptions], [], [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"]) fi _LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1], [Compiler flag to turn off builtin functions]) ])# _LT_COMPILER_NO_RTTI # _LT_CMD_GLOBAL_SYMBOLS # ---------------------- m4_defun([_LT_CMD_GLOBAL_SYMBOLS], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([AC_PROG_AWK])dnl AC_REQUIRE([LT_PATH_NM])dnl AC_REQUIRE([LT_PATH_LD])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_TAG_COMPILER])dnl # Check for command to grab the raw symbol name followed by C symbol from nm. AC_MSG_CHECKING([command to parse $NM output from $compiler object]) AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], [ # These are sane defaults that work on at least a few old systems. # [They come from Ultrix. What could be older than Ultrix?!! ;)] # Character class describing NM global symbol codes. symcode='[[BCDEGRST]]' # Regexp to match symbols that can be accessed directly from C. sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)' # Define system-specific variables. case $host_os in aix*) symcode='[[BCDT]]' ;; cygwin* | mingw* | pw32* | cegcc*) symcode='[[ABCDGISTW]]' ;; hpux*) if test "$host_cpu" = ia64; then symcode='[[ABCDEGRST]]' fi ;; irix* | nonstopux*) symcode='[[BCDEGRST]]' ;; osf*) symcode='[[BCDEGQRST]]' ;; solaris*) symcode='[[BDRT]]' ;; sco3.2v5*) symcode='[[DT]]' ;; sysv4.2uw2*) symcode='[[DT]]' ;; sysv5* | sco5v6* | unixware* | OpenUNIX*) symcode='[[ABDT]]' ;; sysv4) symcode='[[DFNSTU]]' ;; esac # If we're using GNU nm, then use its standard symbol codes. case `$NM -V 2>&1` in *GNU* | *'with BFD'*) symcode='[[ABCDGIRSTW]]' ;; esac # Transform an extracted symbol line into a proper C declaration. # Some systems (esp. on ia64) link data and code symbols differently, # so use this general approach. lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" # Transform an extracted symbol line into symbol name and symbol address lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p'" lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"lib\2\", (void *) \&\2},/p'" # Handle CRLF in mingw tool chain opt_cr= case $build_os in mingw*) opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp ;; esac # Try without a prefix underscore, then with it. for ac_symprfx in "" "_"; do # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. symxfrm="\\1 $ac_symprfx\\2 \\2" # Write the raw and C identifiers. if test "$lt_cv_nm_interface" = "MS dumpbin"; then # Fake it for dumpbin and say T for any non-static function # and D for any global variable. # Also find C++ and __fastcall symbols from MSVC++, # which start with @ or ?. lt_cv_sys_global_symbol_pipe="$AWK ['"\ " {last_section=section; section=\$ 3};"\ " /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ " \$ 0!~/External *\|/{next};"\ " / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ " {if(hide[section]) next};"\ " {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ " {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ " s[1]~/^[@?]/{print s[1], s[1]; next};"\ " s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ " ' prfx=^$ac_symprfx]" else lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" fi lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" # Check to see that the pipe works correctly. pipe_works=no rm -f conftest* cat > conftest.$ac_ext <<_LT_EOF #ifdef __cplusplus extern "C" { #endif char nm_test_var; void nm_test_func(void); void nm_test_func(void){} #ifdef __cplusplus } #endif int main(){nm_test_var='a';nm_test_func();return(0);} _LT_EOF if AC_TRY_EVAL(ac_compile); then # Now try to grab the symbols. nlist=conftest.nm if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then # Try sorting and uniquifying the output. if sort "$nlist" | uniq > "$nlist"T; then mv -f "$nlist"T "$nlist" else rm -f "$nlist"T fi # Make sure that we snagged all the symbols we need. if $GREP ' nm_test_var$' "$nlist" >/dev/null; then if $GREP ' nm_test_func$' "$nlist" >/dev/null; then cat <<_LT_EOF > conftest.$ac_ext /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ #if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) /* DATA imports from DLLs on WIN32 con't be const, because runtime relocations are performed -- see ld's documentation on pseudo-relocs. */ # define LT@&t@_DLSYM_CONST #elif defined(__osf__) /* This system does not cope well with relocations in const data. */ # define LT@&t@_DLSYM_CONST #else # define LT@&t@_DLSYM_CONST const #endif #ifdef __cplusplus extern "C" { #endif _LT_EOF # Now generate the symbol file. eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' cat <<_LT_EOF >> conftest.$ac_ext /* The mapping between symbol names and symbols. */ LT@&t@_DLSYM_CONST struct { const char *name; void *address; } lt__PROGRAM__LTX_preloaded_symbols[[]] = { { "@PROGRAM@", (void *) 0 }, _LT_EOF $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext cat <<\_LT_EOF >> conftest.$ac_ext {0, (void *) 0} }; /* This works around a problem in FreeBSD linker */ #ifdef FREEBSD_WORKAROUND static const void *lt_preloaded_setup() { return lt__PROGRAM__LTX_preloaded_symbols; } #endif #ifdef __cplusplus } #endif _LT_EOF # Now try linking the two files. mv conftest.$ac_objext conftstm.$ac_objext lt_globsym_save_LIBS=$LIBS lt_globsym_save_CFLAGS=$CFLAGS LIBS="conftstm.$ac_objext" CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then pipe_works=yes fi LIBS=$lt_globsym_save_LIBS CFLAGS=$lt_globsym_save_CFLAGS else echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD fi else echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD fi else echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD fi else echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD cat conftest.$ac_ext >&5 fi rm -rf conftest* conftst* # Do not use the global_symbol_pipe unless it works. if test "$pipe_works" = yes; then break else lt_cv_sys_global_symbol_pipe= fi done ]) if test -z "$lt_cv_sys_global_symbol_pipe"; then lt_cv_sys_global_symbol_to_cdecl= fi if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then AC_MSG_RESULT(failed) else AC_MSG_RESULT(ok) fi # Response file support. if test "$lt_cv_nm_interface" = "MS dumpbin"; then nm_file_list_spec='@' elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then nm_file_list_spec='@' fi _LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1], [Take the output of nm and produce a listing of raw symbols and C names]) _LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1], [Transform the output of nm in a proper C declaration]) _LT_DECL([global_symbol_to_c_name_address], [lt_cv_sys_global_symbol_to_c_name_address], [1], [Transform the output of nm in a C name address pair]) _LT_DECL([global_symbol_to_c_name_address_lib_prefix], [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1], [Transform the output of nm in a C name address pair when lib prefix is needed]) _LT_DECL([], [nm_file_list_spec], [1], [Specify filename containing input files for $NM]) ]) # _LT_CMD_GLOBAL_SYMBOLS # _LT_COMPILER_PIC([TAGNAME]) # --------------------------- m4_defun([_LT_COMPILER_PIC], [m4_require([_LT_TAG_COMPILER])dnl _LT_TAGVAR(lt_prog_compiler_wl, $1)= _LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)= m4_if([$1], [CXX], [ # C++ specific cases for pic, static, wl, etc. if test "$GXX" = yes; then _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' case $host_os in aix*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but # adding the `-m68020' flag to GCC prevents building anything better, # like `-m68040'. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' ;; esac ;; beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) # PIC is the default for these OSes. ;; mingw* | cygwin* | os2* | pw32* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). # Although the cygwin gcc ignores -fPIC, still need this for old-style # (--disable-auto-import) libraries m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' ;; *djgpp*) # DJGPP does not support shared libraries at all _LT_TAGVAR(lt_prog_compiler_pic, $1)= ;; haiku*) # PIC is the default for Haiku. # The "-static" flag exists, but is broken. _LT_TAGVAR(lt_prog_compiler_static, $1)= ;; interix[[3-9]]*) # Interix 3.x gcc -fpic/-fPIC options generate broken code. # Instead, we relocate shared libraries at runtime. ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic fi ;; hpux*) # PIC is the default for 64-bit PA HP-UX, but not for 32-bit # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag # sets the default TLS model and affects inlining. case $host_cpu in hppa*64*) ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac ;; *qnx* | *nto*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac else case $host_os in aix[[4-9]]*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' else _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' fi ;; chorus*) case $cc_basename in cxch68*) # Green Hills C++ Compiler # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" ;; esac ;; mingw* | cygwin* | os2* | pw32* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; dgux*) case $cc_basename in ec++*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' ;; ghcx*) # Green Hills C++ Compiler _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; *) ;; esac ;; freebsd* | dragonfly*) # FreeBSD uses GNU C++ ;; hpux9* | hpux10* | hpux11*) case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' if test "$host_cpu" != ia64; then _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' fi ;; aCC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' case $host_cpu in hppa*64*|ia64*) # +Z the default ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' ;; esac ;; *) ;; esac ;; interix*) # This is c89, which is MS Visual C++ (no shared libs) # Anyone wants to do a port? ;; irix5* | irix6* | nonstopux*) case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' # CC pic flag -KPIC is the default. ;; *) ;; esac ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in KCC*) # KAI C++ Compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; ecpc* ) # old Intel C++ for x86_64 which still supported -KPIC. _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; icpc* ) # Intel C++, used to be incompatible with GCC. # ICC 10 doesn't accept -KPIC any more. _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; pgCC* | pgcpp*) # Portland Group C++ compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; cxx*) # Compaq C++ # Make sure the PIC flag is empty. It appears that all Alpha # Linux and Compaq Tru64 Unix objects are PIC. _LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL 8.0, 9.0 on PPC and BlueGene _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' ;; esac ;; esac ;; lynxos*) ;; m88k*) ;; mvs*) case $cc_basename in cxx*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall' ;; *) ;; esac ;; netbsd*) ;; *qnx* | *nto*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; osf3* | osf4* | osf5*) case $cc_basename in KCC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' ;; RCC*) # Rational C++ 2.4.1 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; cxx*) # Digital/Compaq C++ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # Make sure the PIC flag is empty. It appears that all Alpha # Linux and Compaq Tru64 Unix objects are PIC. _LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; *) ;; esac ;; psos*) ;; solaris*) case $cc_basename in CC* | sunCC*) # Sun C++ 4.2, 5.x and Centerline C++ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' ;; gcx*) # Green Hills C++ Compiler _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' ;; *) ;; esac ;; sunos4*) case $cc_basename in CC*) # Sun C++ 4.x _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; lcc*) # Lucid _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' ;; *) ;; esac ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) case $cc_basename in CC*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; esac ;; tandem*) case $cc_basename in NCC*) # NonStop-UX NCC 3.20 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' ;; *) ;; esac ;; vxworks*) ;; *) _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; esac fi ], [ if test "$GCC" = yes; then _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' case $host_os in aix*) # All AIX code is PIC. if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; m68k) # FIXME: we need at least 68020 code to build shared libraries, but # adding the `-m68020' flag to GCC prevents building anything better, # like `-m68040'. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' ;; esac ;; beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) # PIC is the default for these OSes. ;; mingw* | cygwin* | pw32* | os2* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). # Although the cygwin gcc ignores -fPIC, still need this for old-style # (--disable-auto-import) libraries m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; darwin* | rhapsody*) # PIC is the default on this platform # Common symbols not allowed in MH_DYLIB files _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' ;; haiku*) # PIC is the default for Haiku. # The "-static" flag exists, but is broken. _LT_TAGVAR(lt_prog_compiler_static, $1)= ;; hpux*) # PIC is the default for 64-bit PA HP-UX, but not for 32-bit # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag # sets the default TLS model and affects inlining. case $host_cpu in hppa*64*) # +Z the default ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac ;; interix[[3-9]]*) # Interix 3.x gcc -fpic/-fPIC options generate broken code. # Instead, we relocate shared libraries at runtime. ;; msdosdjgpp*) # Just because we use GCC doesn't mean we suddenly get shared libraries # on systems that don't support them. _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no enable_shared=no ;; *nto* | *qnx*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic fi ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' ;; esac case $cc_basename in nvcc*) # Cuda Compiler Driver 2.2 _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker ' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Xcompiler -fPIC' ;; esac else # PORTME Check for flag to pass linker flags through the system compiler. case $host_os in aix*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' if test "$host_cpu" = ia64; then # AIX 5 now supports IA64 processor _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' else _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' fi ;; mingw* | cygwin* | pw32* | os2* | cegcc*) # This hack is so that the source file can tell whether it is being # built for inclusion in a dll (and should export symbols for example). m4_if([$1], [GCJ], [], [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) ;; hpux9* | hpux10* | hpux11*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but # not for PA HP-UX. case $host_cpu in hppa*64*|ia64*) # +Z the default ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' ;; esac # Is there a better lt_prog_compiler_static that works with the bundled CC? _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' ;; irix5* | irix6* | nonstopux*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # PIC (with -KPIC) is the default. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in # old Intel for x86_64 which still supported -KPIC. ecc*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; # icc used to be incompatible with GCC. # ICC 10 doesn't accept -KPIC any more. icc* | ifort*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' ;; # Lahey Fortran 8.1. lf95*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared' _LT_TAGVAR(lt_prog_compiler_static, $1)='--static' ;; nagfor*) # NAG Fortran compiler _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group compilers (*not* the Pentium gcc compiler, # which looks to be a dead project) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; ccc*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # All Alpha code is PIC. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; xl* | bgxl* | bgf* | mpixl*) # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ F* | *Sun*Fortran*) # Sun Fortran 8.3 passes all unrecognized flags to the linker _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='' ;; *Sun\ C*) # Sun C 5.9 _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' ;; esac ;; esac ;; newsos6) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; *nto* | *qnx*) # QNX uses GNU C++, but need to define -shared option too, otherwise # it will coredump. _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' ;; osf3* | osf4* | osf5*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' # All OSF/1 code is PIC. _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; rdos*) _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' ;; solaris*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' case $cc_basename in f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';; *) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';; esac ;; sunos4*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; sysv4 | sysv4.2uw2* | sysv4.3*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; sysv4*MP*) if test -d /usr/nec ;then _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' fi ;; sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; unicos*) _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; uts4*) _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' ;; *) _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no ;; esac fi ]) case $host_os in # For platforms which do not support PIC, -DPIC is meaningless: *djgpp*) _LT_TAGVAR(lt_prog_compiler_pic, $1)= ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])" ;; esac AC_CACHE_CHECK([for $compiler option to produce PIC], [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)], [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)]) _LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1) # # Check to make sure the PIC flag actually works. # if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works], [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)], [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [], [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in "" | " "*) ;; *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;; esac], [_LT_TAGVAR(lt_prog_compiler_pic, $1)= _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no]) fi _LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1], [Additional compiler flags for building library objects]) _LT_TAGDECL([wl], [lt_prog_compiler_wl], [1], [How to pass a linker flag through the compiler]) # # Check to make sure the static flag actually works. # wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\" _LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works], _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1), $lt_tmp_static_flag, [], [_LT_TAGVAR(lt_prog_compiler_static, $1)=]) _LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1], [Compiler flag to prevent dynamic linking]) ])# _LT_COMPILER_PIC # _LT_LINKER_SHLIBS([TAGNAME]) # ---------------------------- # See if the linker supports building shared libraries. m4_defun([_LT_LINKER_SHLIBS], [AC_REQUIRE([LT_PATH_LD])dnl AC_REQUIRE([LT_PATH_NM])dnl m4_require([_LT_PATH_MANIFEST_TOOL])dnl m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_DECL_SED])dnl m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl m4_require([_LT_TAG_COMPILER])dnl AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) m4_if([$1], [CXX], [ _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] case $host_os in aix[[4-9]]*) # If we're using GNU nm, then we don't want the "-C" option. # -C means demangle to AIX nm, but means don't demangle with GNU nm # Also, AIX nm treats weak defined symbols like other global defined # symbols, whereas GNU nm marks them as "W". if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' else _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' fi ;; pw32*) _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds" ;; cygwin* | mingw* | cegcc*) case $cc_basename in cl*) ;; *) _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] ;; esac ;; *) _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' ;; esac ], [ runpath_var= _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_cmds, $1)= _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(compiler_needs_object, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(old_archive_from_new_cmds, $1)= _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)= _LT_TAGVAR(thread_safe_flag_spec, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= # include_expsyms should be a list of space-separated symbols to be *always* # included in the symbol list _LT_TAGVAR(include_expsyms, $1)= # exclude_expsyms can be an extended regexp of symbols to exclude # it will be wrapped by ` (' and `)$', so one must not match beginning or # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', # as well as any symbol that contains `d'. _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out # platforms (ab)use it in PIC code, but their linkers get confused if # the symbol is explicitly referenced. Since portable code cannot # rely on this symbol name, it's probably fine to never include it in # preloaded symbol tables. # Exclude shared library initialization/finalization symbols. dnl Note also adjust exclude_expsyms for C++ above. extract_expsyms_cmds= case $host_os in cygwin* | mingw* | pw32* | cegcc*) # FIXME: the MSVC++ port hasn't been tested in a loooong time # When not using gcc, we currently assume that we are using # Microsoft Visual C++. if test "$GCC" != yes; then with_gnu_ld=no fi ;; interix*) # we just hope/assume this is gcc and not c89 (= MSVC++) with_gnu_ld=yes ;; openbsd*) with_gnu_ld=no ;; esac _LT_TAGVAR(ld_shlibs, $1)=yes # On some targets, GNU ld is compatible enough with the native linker # that we're better off using the native interface for both. lt_use_gnu_ld_interface=no if test "$with_gnu_ld" = yes; then case $host_os in aix*) # The AIX port of GNU ld has always aspired to compatibility # with the native linker. However, as the warning in the GNU ld # block says, versions before 2.19.5* couldn't really create working # shared libraries, regardless of the interface used. case `$LD -v 2>&1` in *\ \(GNU\ Binutils\)\ 2.19.5*) ;; *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;; *\ \(GNU\ Binutils\)\ [[3-9]]*) ;; *) lt_use_gnu_ld_interface=yes ;; esac ;; *) lt_use_gnu_ld_interface=yes ;; esac fi if test "$lt_use_gnu_ld_interface" = yes; then # If archive_cmds runs LD, not CC, wlarc should be empty wlarc='${wl}' # Set some defaults for GNU ld with shared library support. These # are reset later if shared libraries are not supported. Putting them # here allows them to be overridden if necessary. runpath_var=LD_RUN_PATH _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' # ancient GNU ld didn't support --whole-archive et. al. if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' else _LT_TAGVAR(whole_archive_flag_spec, $1)= fi supports_anon_versioning=no case `$LD -v 2>&1` in *GNU\ gold*) supports_anon_versioning=yes ;; *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11 *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... *\ 2.11.*) ;; # other 2.11 versions *) supports_anon_versioning=yes ;; esac # See if GNU ld supports shared libraries. case $host_os in aix[[3-9]]*) # On AIX/PPC, the GNU linker is very broken if test "$host_cpu" != ia64; then _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 *** Warning: the GNU linker, at least up to release 2.19, is reported *** to be unable to reliably create shared libraries on AIX. *** Therefore, libtool is disabling shared libraries support. If you *** really care for shared libraries, you may want to install binutils *** 2.20 or above, or modify your PATH so that a non-GNU linker is found. *** You will then need to restart the configuration process. _LT_EOF fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='' ;; m68k) _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac ;; beos*) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; cygwin* | mingw* | pw32* | cegcc*) # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, # as there is no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' # If the export-symbols file already is a .def file (1st line # is EXPORTS), use it as is; otherwise, prepend... _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then cp $export_symbols $output_objdir/$soname.def; else echo EXPORTS > $output_objdir/$soname.def; cat $export_symbols >> $output_objdir/$soname.def; fi~ $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; haiku*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(link_all_deplibs, $1)=yes ;; interix[[3-9]]*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) tmp_diet=no if test "$host_os" = linux-dietlibc; then case $cc_basename in diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) esac fi if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ && test "$tmp_diet" = no then tmp_addflag=' $pic_flag' tmp_sharedflag='-shared' case $cc_basename,$host_cpu in pgcc*) # Portland Group C compiler _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' tmp_addflag=' $pic_flag' ;; pgf77* | pgf90* | pgf95* | pgfortran*) # Portland Group f77 and f90 compilers _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' tmp_addflag=' $pic_flag -Mnomain' ;; ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 tmp_addflag=' -i_dynamic' ;; efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 tmp_addflag=' -i_dynamic -nofor_main' ;; ifc* | ifort*) # Intel Fortran compiler tmp_addflag=' -nofor_main' ;; lf95*) # Lahey Fortran 8.1 _LT_TAGVAR(whole_archive_flag_spec, $1)= tmp_sharedflag='--shared' ;; xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below) tmp_sharedflag='-qmkshrobj' tmp_addflag= ;; nvcc*) # Cuda Compiler Driver 2.2 _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes ;; esac case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C 5.9 _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes tmp_sharedflag='-G' ;; *Sun\ F*) # Sun Fortran 8.3 tmp_sharedflag='-G' ;; esac _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' if test "x$supports_anon_versioning" = xyes; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' fi case $cc_basename in xlf* | bgf* | bgxlf* | mpixlf*) # IBM XL Fortran 10.1 on PPC cannot create shared libs itself _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir' _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' if test "x$supports_anon_versioning" = xyes; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' fi ;; esac else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' wlarc= else _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' fi ;; solaris*) if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 *** Warning: The releases 2.8.* of the GNU linker cannot reliably *** create shared libraries on Solaris systems. Therefore, libtool *** is disabling shared libraries support. We urge you to upgrade GNU *** binutils to release 2.9.1 or newer. Another option is to modify *** your PATH or compiler configuration so that the native linker is *** used, and then restart. _LT_EOF elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) case `$LD -v 2>&1` in *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) _LT_TAGVAR(ld_shlibs, $1)=no cat <<_LT_EOF 1>&2 *** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not *** reliably create shared libraries on SCO systems. Therefore, libtool *** is disabling shared libraries support. We urge you to upgrade GNU *** binutils to release 2.16.91.0.3 or newer. Another option is to modify *** your PATH or compiler configuration so that the native linker is *** used, and then restart. _LT_EOF ;; *) # For security reasons, it is highly recommended that you always # use absolute paths for naming shared libraries, and exclude the # DT_RUNPATH tag from executables and libraries. But doing so # requires that you compile everything twice, which is a pain. if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; sunos4*) _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' wlarc= _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then runpath_var= _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= fi else # PORTME fill in a description of your system's linker (not GNU ld) case $host_os in aix3*) _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' # Note: this linker hardcodes the directories in LIBPATH if there # are no directories specified by -L. _LT_TAGVAR(hardcode_minus_L, $1)=yes if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then # Neither direct hardcoding nor static linking is supported with a # broken collect2. _LT_TAGVAR(hardcode_direct, $1)=unsupported fi ;; aix[[4-9]]*) if test "$host_cpu" = ia64; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' no_entry_flag="" else # If we're using GNU nm, then we don't want the "-C" option. # -C means demangle to AIX nm, but means don't demangle with GNU nm # Also, AIX nm treats weak defined symbols like other global # defined symbols, whereas GNU nm marks them as "W". if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' else _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' fi aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we # need to do runtime linking. case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) for ld_flag in $LDFLAGS; do if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then aix_use_runtimelinking=yes break fi done ;; esac exp_sym_flag='-bexport' no_entry_flag='-bnoentry' fi # When large executables or shared objects are built, AIX ld can # have problems creating the table of contents. If linking a library # or program results in "error TOC overflow" add -mminimal-toc to # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. _LT_TAGVAR(archive_cmds, $1)='' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' if test "$GCC" = yes; then case $host_os in aix4.[[012]]|aix4.[[012]].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ collect2name=`${CC} -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then # We have reworked collect2 : else # We have old collect2 _LT_TAGVAR(hardcode_direct, $1)=unsupported # It fails to find uninstalled libraries when the uninstalled # path is not listed in the libpath. Setting hardcode_minus_L # to unsupported forces relinking _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)= fi ;; esac shared_flag='-shared' if test "$aix_use_runtimelinking" = yes; then shared_flag="$shared_flag "'${wl}-G' fi else # not using gcc if test "$host_cpu" = ia64; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else if test "$aix_use_runtimelinking" = yes; then shared_flag='${wl}-G' else shared_flag='${wl}-bM:SRE' fi fi fi _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to export. _LT_TAGVAR(always_export_symbols, $1)=yes if test "$aix_use_runtimelinking" = yes; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. _LT_TAGVAR(allow_undefined_flag, $1)='-berok' # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" else if test "$host_cpu" = ia64; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' if test "$with_gnu_ld" = yes; then # We only use this code for GNU lds that support --whole-archive. _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' fi _LT_TAGVAR(archive_cmds_need_lc, $1)=yes # This is similar to how AIX traditionally builds its shared libraries. _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' fi fi ;; amigaos*) case $host_cpu in powerpc) # see comment about AmigaOS4 .so support _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='' ;; m68k) _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac ;; bsdi[[45]]*) _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic ;; cygwin* | mingw* | pw32* | cegcc*) # When not using gcc, we currently assume that we are using # Microsoft Visual C++. # hardcode_libdir_flag_spec is actually meaningless, as there is # no search path for DLLs. case $cc_basename in cl*) # Native MSVC _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(file_list_spec, $1)='@' # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; else sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; fi~ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols' # Don't use ranlib _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ lt_tool_outputfile="@TOOL_OUTPUT@"~ case $lt_outputfile in *.exe|*.EXE) ;; *) lt_outputfile="$lt_outputfile.exe" lt_tool_outputfile="$lt_tool_outputfile.exe" ;; esac~ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; $RM "$lt_outputfile.manifest"; fi' ;; *) # Assume MSVC wrapper _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' # The linker will automatically build a .lib file if we build a DLL. _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' # FIXME: Should let the user specify the lib program. _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes ;; esac ;; darwin* | rhapsody*) _LT_DARWIN_LINKER_FEATURES($1) ;; dgux*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; freebsd1*) _LT_TAGVAR(ld_shlibs, $1)=no ;; # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor # support. Future versions do this automatically, but an explicit c++rt0.o # does not break anything, and helps significantly (at the cost of a little # extra space). freebsd2.2*) _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; # Unfortunately, older versions of FreeBSD 2 do not have this feature. freebsd2*) _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; # FreeBSD 3 and greater uses gcc -shared to do shared libraries. freebsd* | dragonfly*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; hpux9*) if test "$GCC" = yes; then _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' else _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_direct, $1)=yes # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' ;; hpux10*) if test "$GCC" = yes && test "$with_gnu_ld" = no; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' fi if test "$with_gnu_ld" = no; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes fi ;; hpux11*) if test "$GCC" = yes && test "$with_gnu_ld" = no; then case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' ;; esac else case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' ;; *) m4_if($1, [], [ # Older versions of the 11.00 compiler do not understand -b yet # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) _LT_LINKER_OPTION([if $CC understands -b], _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b], [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])], [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) ;; esac fi if test "$with_gnu_ld" = no; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: case $host_cpu in hppa*64*|ia64*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' # hardcode_minus_L: Not really in the search PATH, # but as the default location of the library. _LT_TAGVAR(hardcode_minus_L, $1)=yes ;; esac fi ;; irix5* | irix6* | nonstopux*) if test "$GCC" = yes; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' # Try to use the -exported_symbol ld option, if it does not # work, assume that -exports_file does not work either and # implicitly export all symbols. # This should be the same for all languages, so no per-tag cache variable. AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol], [lt_cv_irix_exported_symbol], [save_LDFLAGS="$LDFLAGS" LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" AC_LINK_IFELSE( [AC_LANG_SOURCE( [AC_LANG_CASE([C], [[int foo (void) { return 0; }]], [C++], [[int foo (void) { return 0; }]], [Fortran 77], [[ subroutine foo end]], [Fortran], [[ subroutine foo end]])])], [lt_cv_irix_exported_symbol=yes], [lt_cv_irix_exported_symbol=no]) LDFLAGS="$save_LDFLAGS"]) if test "$lt_cv_irix_exported_symbol" = yes; then _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' fi else _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(inherit_rpath, $1)=yes _LT_TAGVAR(link_all_deplibs, $1)=yes ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out else _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; newsos6) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *nto* | *qnx*) ;; openbsd*) if test -f /usr/libexec/ld.so; then _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=yes if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' else case $host_os in openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*) _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' ;; esac fi else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; os2*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' ;; osf3*) if test "$GCC" = yes; then _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' else _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: ;; osf4* | osf5*) # as osf3* with the addition of -msym flag if test "$GCC" = yes; then _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' else _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' # Both c and cxx compiler support -rpath directly _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' fi _LT_TAGVAR(archive_cmds_need_lc, $1)='no' _LT_TAGVAR(hardcode_libdir_separator, $1)=: ;; solaris*) _LT_TAGVAR(no_undefined_flag, $1)=' -z defs' if test "$GCC" = yes; then wlarc='${wl}' _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' else case `$CC -V 2>&1` in *"Compilers 5.0"*) wlarc='' _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' ;; *) wlarc='${wl}' _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' ;; esac fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no case $host_os in solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) # The compiler driver will combine and reorder linker options, # but understands `-z linker_flag'. GCC discards it without `$wl', # but is careful enough not to reorder. # Supported since Solaris 2.6 (maybe 2.5.1?) if test "$GCC" = yes; then _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' else _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' fi ;; esac _LT_TAGVAR(link_all_deplibs, $1)=yes ;; sunos4*) if test "x$host_vendor" = xsequent; then # Use $CC to link under sequent, because it throws in some extra .o # files that make .init and .fini sections work. _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; sysv4) case $host_vendor in sni) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true??? ;; siemens) ## LD is ld it makes a PLAMLIB ## CC just makes a GrossModule. _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs' _LT_TAGVAR(hardcode_direct, $1)=no ;; motorola) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie ;; esac runpath_var='LD_RUN_PATH' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; sysv4.3*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport' ;; sysv4*MP*) if test -d /usr/nec; then _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var=LD_RUN_PATH hardcode_runpath_var=yes _LT_TAGVAR(ld_shlibs, $1)=yes fi ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var='LD_RUN_PATH' if test "$GCC" = yes; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; sysv5* | sco3.2v5* | sco5v6*) # Note: We can NOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' runpath_var='LD_RUN_PATH' if test "$GCC" = yes; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' else _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' fi ;; uts4*) _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(ld_shlibs, $1)=no ;; esac if test x$host_vendor = xsni; then case $host in sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym' ;; esac fi fi ]) AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no _LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld _LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl _LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl _LT_DECL([], [extract_expsyms_cmds], [2], [The commands to extract the exported symbol list from a shared archive]) # # Do we need to explicitly link libc? # case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in x|xyes) # Assume -lc should be added _LT_TAGVAR(archive_cmds_need_lc, $1)=yes if test "$enable_shared" = yes && test "$GCC" = yes; then case $_LT_TAGVAR(archive_cmds, $1) in *'~'*) # FIXME: we may have to deal with multi-command sequences. ;; '$CC '*) # Test whether the compiler implicitly links with -lc since on some # systems, -lgcc has to come before -lc. If gcc already passes -lc # to ld, don't add -lc before -lgcc. AC_CACHE_CHECK([whether -lc should be explicitly linked in], [lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1), [$RM conftest* echo "$lt_simple_compile_test_code" > conftest.$ac_ext if AC_TRY_EVAL(ac_compile) 2>conftest.err; then soname=conftest lib=conftest libobjs=conftest.$ac_objext deplibs= wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1) compiler_flags=-v linker_flags=-v verstring= output_objdir=. libname=conftest lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1) _LT_TAGVAR(allow_undefined_flag, $1)= if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) then lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no else lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes fi _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag else cat conftest.err 1>&5 fi $RM conftest* ]) _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1) ;; esac fi ;; esac _LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0], [Whether or not to add -lc for building shared libraries]) _LT_TAGDECL([allow_libtool_libs_with_static_runtimes], [enable_shared_with_static_runtimes], [0], [Whether or not to disallow shared libs when runtime libs are static]) _LT_TAGDECL([], [export_dynamic_flag_spec], [1], [Compiler flag to allow reflexive dlopens]) _LT_TAGDECL([], [whole_archive_flag_spec], [1], [Compiler flag to generate shared objects directly from archives]) _LT_TAGDECL([], [compiler_needs_object], [1], [Whether the compiler copes with passing no objects directly]) _LT_TAGDECL([], [old_archive_from_new_cmds], [2], [Create an old-style archive from a shared archive]) _LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2], [Create a temporary old-style archive to link instead of a shared archive]) _LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive]) _LT_TAGDECL([], [archive_expsym_cmds], [2]) _LT_TAGDECL([], [module_cmds], [2], [Commands used to build a loadable module if different from building a shared archive.]) _LT_TAGDECL([], [module_expsym_cmds], [2]) _LT_TAGDECL([], [with_gnu_ld], [1], [Whether we are building with GNU ld or not]) _LT_TAGDECL([], [allow_undefined_flag], [1], [Flag that allows shared libraries with undefined symbols to be built]) _LT_TAGDECL([], [no_undefined_flag], [1], [Flag that enforces no undefined symbols]) _LT_TAGDECL([], [hardcode_libdir_flag_spec], [1], [Flag to hardcode $libdir into a binary during linking. This must work even if $libdir does not exist]) _LT_TAGDECL([], [hardcode_libdir_flag_spec_ld], [1], [[If ld is used when linking, flag to hardcode $libdir into a binary during linking. This must work even if $libdir does not exist]]) _LT_TAGDECL([], [hardcode_libdir_separator], [1], [Whether we need a single "-rpath" flag with a separated argument]) _LT_TAGDECL([], [hardcode_direct], [0], [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_direct_absolute], [0], [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes DIR into the resulting binary and the resulting library dependency is "absolute", i.e impossible to change by setting ${shlibpath_var} if the library is relocated]) _LT_TAGDECL([], [hardcode_minus_L], [0], [Set to "yes" if using the -LDIR flag during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_shlibpath_var], [0], [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR into the resulting binary]) _LT_TAGDECL([], [hardcode_automatic], [0], [Set to "yes" if building a shared library automatically hardcodes DIR into the library and all subsequent libraries and executables linked against it]) _LT_TAGDECL([], [inherit_rpath], [0], [Set to yes if linker adds runtime paths of dependent libraries to runtime path list]) _LT_TAGDECL([], [link_all_deplibs], [0], [Whether libtool must link a program against all its dependency libraries]) _LT_TAGDECL([], [always_export_symbols], [0], [Set to "yes" if exported symbols are required]) _LT_TAGDECL([], [export_symbols_cmds], [2], [The commands to list exported symbols]) _LT_TAGDECL([], [exclude_expsyms], [1], [Symbols that should not be listed in the preloaded symbols]) _LT_TAGDECL([], [include_expsyms], [1], [Symbols that must always be exported]) _LT_TAGDECL([], [prelink_cmds], [2], [Commands necessary for linking programs (against libraries) with templates]) _LT_TAGDECL([], [postlink_cmds], [2], [Commands necessary for finishing linking programs]) _LT_TAGDECL([], [file_list_spec], [1], [Specify filename containing input files]) dnl FIXME: Not yet implemented dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1], dnl [Compiler flag to generate thread safe objects]) ])# _LT_LINKER_SHLIBS # _LT_LANG_C_CONFIG([TAG]) # ------------------------ # Ensure that the configuration variables for a C compiler are suitably # defined. These variables are subsequently used by _LT_CONFIG to write # the compiler configuration to `libtool'. m4_defun([_LT_LANG_C_CONFIG], [m4_require([_LT_DECL_EGREP])dnl lt_save_CC="$CC" AC_LANG_PUSH(C) # Source file extension for C test sources. ac_ext=c # Object file extension for compiled C test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code="int some_variable = 0;" # Code to be used in simple link tests lt_simple_link_test_code='int main(){return(0);}' _LT_TAG_COMPILER # Save the default compiler, since it gets overwritten when the other # tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. compiler_DEFAULT=$CC # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... if test -n "$compiler"; then _LT_COMPILER_NO_RTTI($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) LT_SYS_DLOPEN_SELF _LT_CMD_STRIPLIB # Report which library types will actually be built AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test "$can_build_shared" = "no" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) test "$enable_shared" = yes && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then test "$enable_shared" = yes && enable_static=no fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_CONFIG($1) fi AC_LANG_POP CC="$lt_save_CC" ])# _LT_LANG_C_CONFIG # _LT_LANG_CXX_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for a C++ compiler are suitably # defined. These variables are subsequently used by _LT_CONFIG to write # the compiler configuration to `libtool'. m4_defun([_LT_LANG_CXX_CONFIG], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl m4_require([_LT_DECL_EGREP])dnl m4_require([_LT_PATH_MANIFEST_TOOL])dnl if test -n "$CXX" && ( test "X$CXX" != "Xno" && ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || (test "X$CXX" != "Xg++"))) ; then AC_PROG_CXXCPP else _lt_caught_CXX_error=yes fi AC_LANG_PUSH(C++) _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(compiler_needs_object, $1)=no _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for C++ test sources. ac_ext=cpp # Object file extension for compiled C++ test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # No sense in running all these tests if we already determined that # the CXX compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. if test "$_lt_caught_CXX_error" != yes; then # Code to be used in simple compile tests lt_simple_compile_test_code="int some_variable = 0;" # Code to be used in simple link tests lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }' # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_LD=$LD lt_save_GCC=$GCC GCC=$GXX lt_save_with_gnu_ld=$with_gnu_ld lt_save_path_LD=$lt_cv_path_LD if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx else $as_unset lt_cv_prog_gnu_ld fi if test -n "${lt_cv_path_LDCXX+set}"; then lt_cv_path_LD=$lt_cv_path_LDCXX else $as_unset lt_cv_path_LD fi test -z "${LDCXX+set}" || LD=$LDCXX CC=${CXX-"c++"} CFLAGS=$CXXFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) if test -n "$compiler"; then # We don't want -fno-exception when compiling C++ code, so set the # no_builtin_flag separately if test "$GXX" = yes; then _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' else _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= fi if test "$GXX" = yes; then # Set up default GNU C++ configuration LT_PATH_LD # Check if GNU C++ uses GNU ld as the underlying linker, since the # archiving commands below assume that GNU ld is being used. if test "$with_gnu_ld" = yes; then _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' # If archive_cmds runs LD, not CC, wlarc should be empty # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to # investigate it a little bit more. (MM) wlarc='${wl}' # ancient GNU ld didn't support --whole-archive et. al. if eval "`$CC -print-prog-name=ld` --help 2>&1" | $GREP 'no-whole-archive' > /dev/null; then _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' else _LT_TAGVAR(whole_archive_flag_spec, $1)= fi else with_gnu_ld=no wlarc= # A generic and very simple default shared library creation # command for GNU C++ for the case where it uses the native # linker, instead of GNU ld. If possible, this setting should # overridden to take advantage of the native linker features on # the platform it is being used on. _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' fi # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else GXX=no with_gnu_ld=no wlarc= fi # PORTME: fill in a description of your system's C++ link characteristics AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) _LT_TAGVAR(ld_shlibs, $1)=yes case $host_os in aix3*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; aix[[4-9]]*) if test "$host_cpu" = ia64; then # On IA64, the linker does run time linking by default, so we don't # have to do anything special. aix_use_runtimelinking=no exp_sym_flag='-Bexport' no_entry_flag="" else aix_use_runtimelinking=no # Test if we are trying to use run time linking or normal # AIX style linking. If -brtl is somewhere in LDFLAGS, we # need to do runtime linking. case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) for ld_flag in $LDFLAGS; do case $ld_flag in *-brtl*) aix_use_runtimelinking=yes break ;; esac done ;; esac exp_sym_flag='-bexport' no_entry_flag='-bnoentry' fi # When large executables or shared objects are built, AIX ld can # have problems creating the table of contents. If linking a library # or program results in "error TOC overflow" add -mminimal-toc to # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. _LT_TAGVAR(archive_cmds, $1)='' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' if test "$GXX" = yes; then case $host_os in aix4.[[012]]|aix4.[[012]].*) # We only want to do this on AIX 4.2 and lower, the check # below for broken collect2 doesn't work under 4.3+ collect2name=`${CC} -print-prog-name=collect2` if test -f "$collect2name" && strings "$collect2name" | $GREP resolve_lib_name >/dev/null then # We have reworked collect2 : else # We have old collect2 _LT_TAGVAR(hardcode_direct, $1)=unsupported # It fails to find uninstalled libraries when the uninstalled # path is not listed in the libpath. Setting hardcode_minus_L # to unsupported forces relinking _LT_TAGVAR(hardcode_minus_L, $1)=yes _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)= fi esac shared_flag='-shared' if test "$aix_use_runtimelinking" = yes; then shared_flag="$shared_flag "'${wl}-G' fi else # not using gcc if test "$host_cpu" = ia64; then # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release # chokes on -Wl,-G. The following line is correct: shared_flag='-G' else if test "$aix_use_runtimelinking" = yes; then shared_flag='${wl}-G' else shared_flag='${wl}-bM:SRE' fi fi fi _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' # It seems that -bexpall does not export symbols beginning with # underscore (_), so it is better to generate a list of symbols to # export. _LT_TAGVAR(always_export_symbols, $1)=yes if test "$aix_use_runtimelinking" = yes; then # Warning - without using the other runtime loading flags (-brtl), # -berok will link without error, but may produce a broken library. _LT_TAGVAR(allow_undefined_flag, $1)='-berok' # Determine the default libpath from the value encoded in an empty # executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" else if test "$host_cpu" = ia64; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" else # Determine the default libpath from the value encoded in an # empty executable. _LT_SYS_MODULE_PATH_AIX([$1]) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" # Warning - without using the other run time loading flags, # -berok will link without error, but may produce a broken library. _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' if test "$with_gnu_ld" = yes; then # We only use this code for GNU lds that support --whole-archive. _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' else # Exported symbols can be pulled into shared objects from archives _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' fi _LT_TAGVAR(archive_cmds_need_lc, $1)=yes # This is similar to how AIX traditionally builds its shared # libraries. _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' fi fi ;; beos*) if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then _LT_TAGVAR(allow_undefined_flag, $1)=unsupported # Joseph Beckenbach says some releases of gcc # support --undefined. This deserves some investigation. FIXME _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; chorus*) case $cc_basename in *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; cygwin* | mingw* | pw32* | cegcc*) case $GXX,$cc_basename in ,cl* | no,cl*) # Native MSVC # hardcode_libdir_flag_spec is actually meaningless, as there is # no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=yes _LT_TAGVAR(file_list_spec, $1)='@' # Tell ltmain to make .lib files, not .a files. libext=lib # Tell ltmain to make .dll files, not .so files. shrext_cmds=".dll" # FIXME: Setting linknames here is a bad hack. _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; else $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; fi~ $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ linknames=' # The linker will not automatically build a static lib if we build a DLL. # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes # Don't use ranlib _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ lt_tool_outputfile="@TOOL_OUTPUT@"~ case $lt_outputfile in *.exe|*.EXE) ;; *) lt_outputfile="$lt_outputfile.exe" lt_tool_outputfile="$lt_tool_outputfile.exe" ;; esac~ func_to_tool_file "$lt_outputfile"~ if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; $RM "$lt_outputfile.manifest"; fi' ;; *) # g++ # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, # as there is no search path for DLLs. _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' _LT_TAGVAR(allow_undefined_flag, $1)=unsupported _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' # If the export-symbols file already is a .def file (1st line # is EXPORTS), use it as is; otherwise, prepend... _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then cp $export_symbols $output_objdir/$soname.def; else echo EXPORTS > $output_objdir/$soname.def; cat $export_symbols >> $output_objdir/$soname.def; fi~ $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; darwin* | rhapsody*) _LT_DARWIN_LINKER_FEATURES($1) ;; dgux*) case $cc_basename in ec++*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; ghcx*) # Green Hills C++ Compiler # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; freebsd[[12]]*) # C++ shared libraries reported to be fairly broken before # switch to ELF _LT_TAGVAR(ld_shlibs, $1)=no ;; freebsd-elf*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; freebsd* | dragonfly*) # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF # conventions _LT_TAGVAR(ld_shlibs, $1)=yes ;; gnu*) ;; haiku*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(link_all_deplibs, $1)=yes ;; hpux9*) _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, # but as the default # location of the library. case $cc_basename in CC*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; aCC*) _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes; then _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' else # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; hpux10*|hpux11*) if test $with_gnu_ld = no; then _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: case $host_cpu in hppa*64*|ia64*) ;; *) _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' ;; esac fi case $host_cpu in hppa*64*|ia64*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no ;; *) _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, # but as the default # location of the library. ;; esac case $cc_basename in CC*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; aCC*) case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; esac # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes; then if test $with_gnu_ld = no; then case $host_cpu in hppa*64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; ia64*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' ;; esac fi else # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; interix[[3-9]]*) _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. # Instead, shared libraries are loaded at an image base (0x10000000 by # default) and relocated if they conflict, which is a slow very memory # consuming and fragmenting process. To avoid this, we pick a random, # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link # time. Moving up from 0x10000000 also allows more sbrk(2) space. _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' ;; irix5* | irix6*) case $cc_basename in CC*) # SGI C++ _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' # Archives containing C++ object files must be created using # "CC -ar", where "CC" is the IRIX C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' ;; *) if test "$GXX" = yes; then if test "$with_gnu_ld" = no; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' else _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' fi fi _LT_TAGVAR(link_all_deplibs, $1)=yes ;; esac _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: _LT_TAGVAR(inherit_rpath, $1)=yes ;; linux* | k*bsd*-gnu | kopensolaris*-gnu) case $cc_basename in KCC*) # Kuck and Associates, Inc. (KAI) C++ Compiler # KCC will only create a shared library if the output file # ends with ".so" (or ".sl" for HP-UX), so rename the library # to its proper name (with version) after linking. _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' # Archives containing C++ object files must be created using # "CC -Bstatic", where "CC" is the KAI C++ compiler. _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; icpc* | ecpc* ) # Intel C++ with_gnu_ld=yes # version 8.0 and above of icpc choke on multiply defined symbols # if we add $predep_objects and $postdep_objects, however 7.1 and # earlier do not add the objects themselves. case `$CC -V 2>&1` in *"Version 7."*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ;; *) # Version 8.0 or newer tmp_idyn= case $host_cpu in ia64*) tmp_idyn=' -i_dynamic';; esac _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' ;; esac _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' ;; pgCC* | pgcpp*) # Portland Group C++ compiler case `$CC -V` in *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*) _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ $RANLIB $oldlib' _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~ rm -rf $tpldir~ $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' ;; *) # Version 6 and above use weak symbols _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' ;; esac _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' ;; cxx*) # Compaq C++ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' runpath_var=LD_RUN_PATH _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' ;; xl* | mpixl* | bgxl*) # IBM XL 8.0 on PPC, with GNU ld _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' if test "x$supports_anon_versioning" = xyes; then _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ echo "local: *; };" >> $output_objdir/$libname.ver~ $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' fi ;; *) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' _LT_TAGVAR(compiler_needs_object, $1)=yes # Not sure whether something based on # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 # would be better. output_verbose_link_cmd='func_echo_all' # Archives containing C++ object files must be created using # "CC -xar", where "CC" is the Sun C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' ;; esac ;; esac ;; lynxos*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; m88k*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; mvs*) case $cc_basename in cxx*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; netbsd*) if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' wlarc= _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no fi # Workaround some broken pre-1.5 toolchains output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' ;; *nto* | *qnx*) _LT_TAGVAR(ld_shlibs, $1)=yes ;; openbsd2*) # C++ shared libraries are fairly broken _LT_TAGVAR(ld_shlibs, $1)=no ;; openbsd*) if test -f /usr/libexec/ld.so; then _LT_TAGVAR(hardcode_direct, $1)=yes _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=yes _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' fi output_verbose_link_cmd=func_echo_all else _LT_TAGVAR(ld_shlibs, $1)=no fi ;; osf3* | osf4* | osf5*) case $cc_basename in KCC*) # Kuck and Associates, Inc. (KAI) C++ Compiler # KCC will only create a shared library if the output file # ends with ".so" (or ".sl" for HP-UX), so rename the library # to its proper name (with version) after linking. _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Archives containing C++ object files must be created using # the KAI C++ compiler. case $host in osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;; esac ;; RCC*) # Rational C++ 2.4.1 # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; cxx*) case $host in osf3*) _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' ;; *) _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ echo "-hidden">> $lib.exp~ $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ $RM $lib.exp' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' ;; esac _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. # # There doesn't appear to be a way to prevent this compiler from # explicitly linking system object files so we need to strip them # from the output so that they don't get included in the library # dependencies. output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' ;; *) if test "$GXX" = yes && test "$with_gnu_ld" = no; then _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' case $host in osf3*) _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' ;; esac _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=: # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no fi ;; esac ;; psos*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; sunos4*) case $cc_basename in CC*) # Sun C++ 4.x # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; lcc*) # Lucid # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; solaris*) case $cc_basename in CC* | sunCC*) # Sun C++ 4.2, 5.x and Centerline C++ _LT_TAGVAR(archive_cmds_need_lc,$1)=yes _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' _LT_TAGVAR(hardcode_shlibpath_var, $1)=no case $host_os in solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) # The compiler driver will combine and reorder linker options, # but understands `-z linker_flag'. # Supported since Solaris 2.6 (maybe 2.5.1?) _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;; esac _LT_TAGVAR(link_all_deplibs, $1)=yes output_verbose_link_cmd='func_echo_all' # Archives containing C++ object files must be created using # "CC -xar", where "CC" is the Sun C++ compiler. This is # necessary to make sure instantiated templates are included # in the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' ;; gcx*) # Green Hills C++ Compiler _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' # The C++ compiler must be used to create the archive. _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' ;; *) # GNU C++ compiler with Solaris linker if test "$GXX" = yes && test "$with_gnu_ld" = no; then _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs' if $CC --version | $GREP -v '^2\.7' > /dev/null; then _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' else # g++ 2.7 appears to require `-G' NOT `-shared' on this # platform. _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' # Commands to make compiler produce verbose output that lists # what "hidden" libraries, object files and flags are used when # linking a shared library. output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' fi _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir' case $host_os in solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; *) _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' ;; esac fi ;; esac ;; sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no runpath_var='LD_RUN_PATH' case $cc_basename in CC*) _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; sysv5* | sco3.2v5* | sco5v6*) # Note: We can NOT use -z defs as we might desire, because we do not # link with -lc, and that would cause any symbols used from libc to # always be unresolved, which means just about no library would # ever link correctly. If we're not using GNU ld we use -z text # though, which does catch some bad symbols but isn't as heavy-handed # as -z defs. _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(hardcode_shlibpath_var, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' _LT_TAGVAR(hardcode_libdir_separator, $1)=':' _LT_TAGVAR(link_all_deplibs, $1)=yes _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' runpath_var='LD_RUN_PATH' case $cc_basename in CC*) _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~ '"$_LT_TAGVAR(old_archive_cmds, $1)" _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~ '"$_LT_TAGVAR(reload_cmds, $1)" ;; *) _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' ;; esac ;; tandem*) case $cc_basename in NCC*) # NonStop-UX NCC 3.20 # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac ;; vxworks*) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; *) # FIXME: insert proper C++ library support _LT_TAGVAR(ld_shlibs, $1)=no ;; esac AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no _LT_TAGVAR(GCC, $1)="$GXX" _LT_TAGVAR(LD, $1)="$LD" ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... _LT_SYS_HIDDEN_LIBDEPS($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi # test -n "$compiler" CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS LDCXX=$LD LD=$lt_save_LD GCC=$lt_save_GCC with_gnu_ld=$lt_save_with_gnu_ld lt_cv_path_LDCXX=$lt_cv_path_LD lt_cv_path_LD=$lt_save_path_LD lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld fi # test "$_lt_caught_CXX_error" != yes AC_LANG_POP ])# _LT_LANG_CXX_CONFIG # _LT_FUNC_STRIPNAME_CNF # ---------------------- # func_stripname_cnf prefix suffix name # strip PREFIX and SUFFIX off of NAME. # PREFIX and SUFFIX must not contain globbing or regex special # characters, hashes, percent signs, but SUFFIX may contain a leading # dot (in which case that matches only a dot). # # This function is identical to the (non-XSI) version of func_stripname, # except this one can be used by m4 code that may be executed by configure, # rather than the libtool script. m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl AC_REQUIRE([_LT_DECL_SED]) AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH]) func_stripname_cnf () { case ${2} in .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; esac } # func_stripname_cnf ])# _LT_FUNC_STRIPNAME_CNF # _LT_SYS_HIDDEN_LIBDEPS([TAGNAME]) # --------------------------------- # Figure out "hidden" library dependencies from verbose # compiler output when linking a shared library. # Parse the compiler output and extract the necessary # objects, libraries and library flags. m4_defun([_LT_SYS_HIDDEN_LIBDEPS], [m4_require([_LT_FILEUTILS_DEFAULTS])dnl AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl # Dependencies to place before and after the object being linked: _LT_TAGVAR(predep_objects, $1)= _LT_TAGVAR(postdep_objects, $1)= _LT_TAGVAR(predeps, $1)= _LT_TAGVAR(postdeps, $1)= _LT_TAGVAR(compiler_lib_search_path, $1)= dnl we can't use the lt_simple_compile_test_code here, dnl because it contains code intended for an executable, dnl not a library. It's possible we should let each dnl tag define a new lt_????_link_test_code variable, dnl but it's only used here... m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF int a; void foo (void) { a = 0; } _LT_EOF ], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF class Foo { public: Foo (void) { a = 0; } private: int a; }; _LT_EOF ], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF subroutine foo implicit none integer*4 a a=0 return end _LT_EOF ], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF subroutine foo implicit none integer a a=0 return end _LT_EOF ], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF public class foo { private int a; public void bar (void) { a = 0; } }; _LT_EOF ]) _lt_libdeps_save_CFLAGS=$CFLAGS case "$CC $CFLAGS " in #( *\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; *\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; esac dnl Parse the compiler output and extract the necessary dnl objects, libraries and library flags. if AC_TRY_EVAL(ac_compile); then # Parse the compiler output and extract the necessary # objects, libraries and library flags. # Sentinel used to keep track of whether or not we are before # the conftest object file. pre_test_object_deps_done=no for p in `eval "$output_verbose_link_cmd"`; do case ${prev}${p} in -L* | -R* | -l*) # Some compilers place space between "-{L,R}" and the path. # Remove the space. if test $p = "-L" || test $p = "-R"; then prev=$p continue fi # Expand the sysroot to ease extracting the directories later. if test -z "$prev"; then case $p in -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; esac fi case $p in =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; esac if test "$pre_test_object_deps_done" = no; then case ${prev} in -L | -R) # Internal compiler library paths should come after those # provided the user. The postdeps already come after the # user supplied libs so there is no need to process them. if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}" else _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}" fi ;; # The "-l" case would never come before the object being # linked, so don't bother handling this case. esac else if test -z "$_LT_TAGVAR(postdeps, $1)"; then _LT_TAGVAR(postdeps, $1)="${prev}${p}" else _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}" fi fi prev= ;; *.lto.$objext) ;; # Ignore GCC LTO objects *.$objext) # This assumes that the test object file only shows up # once in the compiler output. if test "$p" = "conftest.$objext"; then pre_test_object_deps_done=yes continue fi if test "$pre_test_object_deps_done" = no; then if test -z "$_LT_TAGVAR(predep_objects, $1)"; then _LT_TAGVAR(predep_objects, $1)="$p" else _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p" fi else if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then _LT_TAGVAR(postdep_objects, $1)="$p" else _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p" fi fi ;; *) ;; # Ignore the rest. esac done # Clean up. rm -f a.out a.exe else echo "libtool.m4: error: problem compiling $1 test program" fi $RM -f confest.$objext CFLAGS=$_lt_libdeps_save_CFLAGS # PORTME: override above test on systems where it is broken m4_if([$1], [CXX], [case $host_os in interix[[3-9]]*) # Interix 3.5 installs completely hosed .la files for C++, so rather than # hack all around it, let's just trust "g++" to DTRT. _LT_TAGVAR(predep_objects,$1)= _LT_TAGVAR(postdep_objects,$1)= _LT_TAGVAR(postdeps,$1)= ;; linux*) case `$CC -V 2>&1 | sed 5q` in *Sun\ C*) # Sun C++ 5.9 # The more standards-conforming stlport4 library is # incompatible with the Cstd library. Avoid specifying # it if it's in CXXFLAGS. Ignore libCrun as # -library=stlport4 depends on it. case " $CXX $CXXFLAGS " in *" -library=stlport4 "*) solaris_use_stlport4=yes ;; esac if test "$solaris_use_stlport4" != yes; then _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' fi ;; esac ;; solaris*) case $cc_basename in CC* | sunCC*) # The more standards-conforming stlport4 library is # incompatible with the Cstd library. Avoid specifying # it if it's in CXXFLAGS. Ignore libCrun as # -library=stlport4 depends on it. case " $CXX $CXXFLAGS " in *" -library=stlport4 "*) solaris_use_stlport4=yes ;; esac # Adding this requires a known-good setup of shared libraries for # Sun compiler versions before 5.6, else PIC objects from an old # archive will be linked into the output, leading to subtle bugs. if test "$solaris_use_stlport4" != yes; then _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' fi ;; esac ;; esac ]) case " $_LT_TAGVAR(postdeps, $1) " in *" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; esac _LT_TAGVAR(compiler_lib_search_dirs, $1)= if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` fi _LT_TAGDECL([], [compiler_lib_search_dirs], [1], [The directories searched by this compiler when creating a shared library]) _LT_TAGDECL([], [predep_objects], [1], [Dependencies to place before and after the objects being linked to create a shared library]) _LT_TAGDECL([], [postdep_objects], [1]) _LT_TAGDECL([], [predeps], [1]) _LT_TAGDECL([], [postdeps], [1]) _LT_TAGDECL([], [compiler_lib_search_path], [1], [The library search path used internally by the compiler when linking a shared library]) ])# _LT_SYS_HIDDEN_LIBDEPS # _LT_LANG_F77_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for a Fortran 77 compiler are # suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_F77_CONFIG], [AC_LANG_PUSH(Fortran 77) if test -z "$F77" || test "X$F77" = "Xno"; then _lt_disable_F77=yes fi _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for f77 test sources. ac_ext=f # Object file extension for compiled f77 test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # No sense in running all these tests if we already determined that # the F77 compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. if test "$_lt_disable_F77" != yes; then # Code to be used in simple compile tests lt_simple_compile_test_code="\ subroutine t return end " # Code to be used in simple link tests lt_simple_link_test_code="\ program t end " # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC="$CC" lt_save_GCC=$GCC lt_save_CFLAGS=$CFLAGS CC=${F77-"f77"} CFLAGS=$FFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) GCC=$G77 if test -n "$compiler"; then AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test "$can_build_shared" = "no" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) test "$enable_shared" = yes && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then test "$enable_shared" = yes && enable_static=no fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_TAGVAR(GCC, $1)="$G77" _LT_TAGVAR(LD, $1)="$LD" ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi # test -n "$compiler" GCC=$lt_save_GCC CC="$lt_save_CC" CFLAGS="$lt_save_CFLAGS" fi # test "$_lt_disable_F77" != yes AC_LANG_POP ])# _LT_LANG_F77_CONFIG # _LT_LANG_FC_CONFIG([TAG]) # ------------------------- # Ensure that the configuration variables for a Fortran compiler are # suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_FC_CONFIG], [AC_LANG_PUSH(Fortran) if test -z "$FC" || test "X$FC" = "Xno"; then _lt_disable_FC=yes fi _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(allow_undefined_flag, $1)= _LT_TAGVAR(always_export_symbols, $1)=no _LT_TAGVAR(archive_expsym_cmds, $1)= _LT_TAGVAR(export_dynamic_flag_spec, $1)= _LT_TAGVAR(hardcode_direct, $1)=no _LT_TAGVAR(hardcode_direct_absolute, $1)=no _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= _LT_TAGVAR(hardcode_libdir_flag_spec_ld, $1)= _LT_TAGVAR(hardcode_libdir_separator, $1)= _LT_TAGVAR(hardcode_minus_L, $1)=no _LT_TAGVAR(hardcode_automatic, $1)=no _LT_TAGVAR(inherit_rpath, $1)=no _LT_TAGVAR(module_cmds, $1)= _LT_TAGVAR(module_expsym_cmds, $1)= _LT_TAGVAR(link_all_deplibs, $1)=unknown _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds _LT_TAGVAR(no_undefined_flag, $1)= _LT_TAGVAR(whole_archive_flag_spec, $1)= _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no # Source file extension for fc test sources. ac_ext=${ac_fc_srcext-f} # Object file extension for compiled fc test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # No sense in running all these tests if we already determined that # the FC compiler isn't working. Some variables (like enable_shared) # are currently assumed to apply to all compilers on this platform, # and will be corrupted by setting them based on a non-working compiler. if test "$_lt_disable_FC" != yes; then # Code to be used in simple compile tests lt_simple_compile_test_code="\ subroutine t return end " # Code to be used in simple link tests lt_simple_link_test_code="\ program t end " # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC="$CC" lt_save_GCC=$GCC lt_save_CFLAGS=$CFLAGS CC=${FC-"f95"} CFLAGS=$FCFLAGS compiler=$CC GCC=$ac_cv_fc_compiler_gnu _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) if test -n "$compiler"; then AC_MSG_CHECKING([if libtool supports shared libraries]) AC_MSG_RESULT([$can_build_shared]) AC_MSG_CHECKING([whether to build shared libraries]) test "$can_build_shared" = "no" && enable_shared=no # On AIX, shared libraries and static libraries use the same namespace, and # are all built from PIC. case $host_os in aix3*) test "$enable_shared" = yes && enable_static=no if test -n "$RANLIB"; then archive_cmds="$archive_cmds~\$RANLIB \$lib" postinstall_cmds='$RANLIB $lib' fi ;; aix[[4-9]]*) if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then test "$enable_shared" = yes && enable_static=no fi ;; esac AC_MSG_RESULT([$enable_shared]) AC_MSG_CHECKING([whether to build static libraries]) # Make sure either enable_shared or enable_static is yes. test "$enable_shared" = yes || enable_static=yes AC_MSG_RESULT([$enable_static]) _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu" _LT_TAGVAR(LD, $1)="$LD" ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... _LT_SYS_HIDDEN_LIBDEPS($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_SYS_DYNAMIC_LINKER($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi # test -n "$compiler" GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS fi # test "$_lt_disable_FC" != yes AC_LANG_POP ])# _LT_LANG_FC_CONFIG # _LT_LANG_GCJ_CONFIG([TAG]) # -------------------------- # Ensure that the configuration variables for the GNU Java Compiler compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_GCJ_CONFIG], [AC_REQUIRE([LT_PROG_GCJ])dnl AC_LANG_SAVE # Source file extension for Java test sources. ac_ext=java # Object file extension for compiled Java test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code="class foo {}" # Code to be used in simple link tests lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }' # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC=$CC lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC=yes CC=${GCJ-"gcj"} CFLAGS=$GCJFLAGS compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_TAGVAR(LD, $1)="$LD" _LT_CC_BASENAME([$compiler]) # GCJ did not exist at the time GCC didn't implicitly link libc in. _LT_TAGVAR(archive_cmds_need_lc, $1)=no _LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds _LT_TAGVAR(reload_flag, $1)=$reload_flag _LT_TAGVAR(reload_cmds, $1)=$reload_cmds ## CAVEAT EMPTOR: ## There is no encapsulation within the following macros, do not change ## the running order or otherwise move them around unless you know exactly ## what you are doing... if test -n "$compiler"; then _LT_COMPILER_NO_RTTI($1) _LT_COMPILER_PIC($1) _LT_COMPILER_C_O($1) _LT_COMPILER_FILE_LOCKS($1) _LT_LINKER_SHLIBS($1) _LT_LINKER_HARDCODE_LIBPATH($1) _LT_CONFIG($1) fi AC_LANG_RESTORE GCC=$lt_save_GCC CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS ])# _LT_LANG_GCJ_CONFIG # _LT_LANG_RC_CONFIG([TAG]) # ------------------------- # Ensure that the configuration variables for the Windows resource compiler # are suitably defined. These variables are subsequently used by _LT_CONFIG # to write the compiler configuration to `libtool'. m4_defun([_LT_LANG_RC_CONFIG], [AC_REQUIRE([LT_PROG_RC])dnl AC_LANG_SAVE # Source file extension for RC test sources. ac_ext=rc # Object file extension for compiled RC test sources. objext=o _LT_TAGVAR(objext, $1)=$objext # Code to be used in simple compile tests lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }' # Code to be used in simple link tests lt_simple_link_test_code="$lt_simple_compile_test_code" # ltmain only uses $CC for tagged configurations so make sure $CC is set. _LT_TAG_COMPILER # save warnings/boilerplate of simple test code _LT_COMPILER_BOILERPLATE _LT_LINKER_BOILERPLATE # Allow CC to be a program name with arguments. lt_save_CC="$CC" lt_save_CFLAGS=$CFLAGS lt_save_GCC=$GCC GCC= CC=${RC-"windres"} CFLAGS= compiler=$CC _LT_TAGVAR(compiler, $1)=$CC _LT_CC_BASENAME([$compiler]) _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes if test -n "$compiler"; then : _LT_CONFIG($1) fi GCC=$lt_save_GCC AC_LANG_RESTORE CC=$lt_save_CC CFLAGS=$lt_save_CFLAGS ])# _LT_LANG_RC_CONFIG # LT_PROG_GCJ # ----------- AC_DEFUN([LT_PROG_GCJ], [m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], [AC_CHECK_TOOL(GCJ, gcj,) test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2" AC_SUBST(GCJFLAGS)])])[]dnl ]) # Old name: AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_GCJ], []) # LT_PROG_RC # ---------- AC_DEFUN([LT_PROG_RC], [AC_CHECK_TOOL(RC, windres,) ]) # Old name: AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_RC], []) # _LT_DECL_EGREP # -------------- # If we don't have a new enough Autoconf to choose the best grep # available, choose the one first in the user's PATH. m4_defun([_LT_DECL_EGREP], [AC_REQUIRE([AC_PROG_EGREP])dnl AC_REQUIRE([AC_PROG_FGREP])dnl test -z "$GREP" && GREP=grep _LT_DECL([], [GREP], [1], [A grep program that handles long lines]) _LT_DECL([], [EGREP], [1], [An ERE matcher]) _LT_DECL([], [FGREP], [1], [A literal string matcher]) dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too AC_SUBST([GREP]) ]) # _LT_DECL_OBJDUMP # -------------- # If we don't have a new enough Autoconf to choose the best objdump # available, choose the one first in the user's PATH. m4_defun([_LT_DECL_OBJDUMP], [AC_CHECK_TOOL(OBJDUMP, objdump, false) test -z "$OBJDUMP" && OBJDUMP=objdump _LT_DECL([], [OBJDUMP], [1], [An object symbol dumper]) AC_SUBST([OBJDUMP]) ]) # _LT_DECL_DLLTOOL # ---------------- # Ensure DLLTOOL variable is set. m4_defun([_LT_DECL_DLLTOOL], [AC_CHECK_TOOL(DLLTOOL, dlltool, false) test -z "$DLLTOOL" && DLLTOOL=dlltool _LT_DECL([], [DLLTOOL], [1], [DLL creation program]) AC_SUBST([DLLTOOL]) ]) # _LT_DECL_SED # ------------ # Check for a fully-functional sed program, that truncates # as few characters as possible. Prefer GNU sed if found. m4_defun([_LT_DECL_SED], [AC_PROG_SED test -z "$SED" && SED=sed Xsed="$SED -e 1s/^X//" _LT_DECL([], [SED], [1], [A sed program that does not truncate output]) _LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"], [Sed that helps us avoid accidentally triggering echo(1) options like -n]) ])# _LT_DECL_SED m4_ifndef([AC_PROG_SED], [ ############################################################ # NOTE: This macro has been submitted for inclusion into # # GNU Autoconf as AC_PROG_SED. When it is available in # # a released version of Autoconf we should remove this # # macro and use it instead. # ############################################################ m4_defun([AC_PROG_SED], [AC_MSG_CHECKING([for a sed that does not truncate output]) AC_CACHE_VAL(lt_cv_path_SED, [# Loop through the user's path and test for sed and gsed. # Then use that list of sed's as ones to test for truncation. as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for lt_ac_prog in sed gsed; do for ac_exec_ext in '' $ac_executable_extensions; do if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" fi done done done IFS=$as_save_IFS lt_ac_max=0 lt_ac_count=0 # Add /usr/xpg4/bin/sed as it is typically found on Solaris # along with /bin/sed that truncates output. for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do test ! -f $lt_ac_sed && continue cat /dev/null > conftest.in lt_ac_count=0 echo $ECHO_N "0123456789$ECHO_C" >conftest.in # Check for GNU sed and select it if it is found. if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then lt_cv_path_SED=$lt_ac_sed break fi while true; do cat conftest.in conftest.in >conftest.tmp mv conftest.tmp conftest.in cp conftest.in conftest.nl echo >>conftest.nl $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break cmp -s conftest.out conftest.nl || break # 10000 chars as input seems more than enough test $lt_ac_count -gt 10 && break lt_ac_count=`expr $lt_ac_count + 1` if test $lt_ac_count -gt $lt_ac_max; then lt_ac_max=$lt_ac_count lt_cv_path_SED=$lt_ac_sed fi done done ]) SED=$lt_cv_path_SED AC_SUBST([SED]) AC_MSG_RESULT([$SED]) ])#AC_PROG_SED ])#m4_ifndef # Old name: AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED]) dnl aclocal-1.4 backwards compatibility: dnl AC_DEFUN([LT_AC_PROG_SED], []) # _LT_CHECK_SHELL_FEATURES # ------------------------ # Find out whether the shell is Bourne or XSI compatible, # or has some other useful features. m4_defun([_LT_CHECK_SHELL_FEATURES], [AC_MSG_CHECKING([whether the shell understands some XSI constructs]) # Try some XSI features xsi_shell=no ( _lt_dummy="a/b/c" test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ = c,a/b,b/c, \ && eval 'test $(( 1 + 1 )) -eq 2 \ && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ && xsi_shell=yes AC_MSG_RESULT([$xsi_shell]) _LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell']) AC_MSG_CHECKING([whether the shell understands "+="]) lt_shell_append=no ( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \ >/dev/null 2>&1 \ && lt_shell_append=yes AC_MSG_RESULT([$lt_shell_append]) _LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append']) if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then lt_unset=unset else lt_unset=false fi _LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl # test EBCDIC or ASCII case `echo X|tr X '\101'` in A) # ASCII based system # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr lt_SP2NL='tr \040 \012' lt_NL2SP='tr \015\012 \040\040' ;; *) # EBCDIC based system lt_SP2NL='tr \100 \n' lt_NL2SP='tr \r\n \100\100' ;; esac _LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl _LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl ])# _LT_CHECK_SHELL_FEATURES # _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY) # ------------------------------------------------------ # In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and # '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY. m4_defun([_LT_PROG_FUNCTION_REPLACE], [dnl { sed -e '/^$1 ()$/,/^} # $1 /c\ $1 ()\ {\ m4_bpatsubsts([$2], [$], [\\], [^\([ ]\)], [\\\1]) } # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: ]) # _LT_PROG_REPLACE_SHELLFNS # ------------------------- # Replace existing portable implementations of several shell functions with # equivalent extended shell implementations where those features are available.. m4_defun([_LT_PROG_REPLACE_SHELLFNS], [if test x"$xsi_shell" = xyes; then _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl case ${1} in */*) func_dirname_result="${1%/*}${2}" ;; * ) func_dirname_result="${3}" ;; esac]) _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl func_basename_result="${1##*/}"]) _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl case ${1} in */*) func_dirname_result="${1%/*}${2}" ;; * ) func_dirname_result="${3}" ;; esac func_basename_result="${1##*/}"]) _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are # positional parameters, so assign one to ordinary parameter first. func_stripname_result=${3} func_stripname_result=${func_stripname_result#"${1}"} func_stripname_result=${func_stripname_result%"${2}"}]) _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl func_split_long_opt_name=${1%%=*} func_split_long_opt_arg=${1#*=}]) _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl func_split_short_opt_arg=${1#??} func_split_short_opt_name=${1%"$func_split_short_opt_arg"}]) _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl case ${1} in *.lo) func_lo2o_result=${1%.lo}.${objext} ;; *) func_lo2o_result=${1} ;; esac]) _LT_PROG_FUNCTION_REPLACE([func_xform], [ func_xform_result=${1%.*}.lo]) _LT_PROG_FUNCTION_REPLACE([func_arith], [ func_arith_result=$(( $[*] ))]) _LT_PROG_FUNCTION_REPLACE([func_len], [ func_len_result=${#1}]) fi if test x"$lt_shell_append" = xyes; then _LT_PROG_FUNCTION_REPLACE([func_append], [ eval "${1}+=\\${2}"]) _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl func_quote_for_eval "${2}" dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \ eval "${1}+=\\\\ \\$func_quote_for_eval_result"]) # Save a `func_append' function call where possible by direct use of '+=' sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: else # Save a `func_append' function call even when '+=' is not available sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ && mv -f "$cfgfile.tmp" "$cfgfile" \ || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") test 0 -eq $? || _lt_function_replace_fail=: fi if test x"$_lt_function_replace_fail" = x":"; then AC_MSG_WARN([Unable to substitute extended shell functions in $ofile]) fi ]) # _LT_PATH_CONVERSION_FUNCTIONS # ----------------------------- # Determine which file name conversion functions should be used by # func_to_host_file (and, implicitly, by func_to_host_path). These are needed # for certain cross-compile configurations and native mingw. m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], [AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([AC_CANONICAL_BUILD])dnl AC_MSG_CHECKING([how to convert $build file names to $host format]) AC_CACHE_VAL(lt_cv_to_host_file_cmd, [case $host in *-*-mingw* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 ;; *-*-cygwin* ) lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 ;; * ) # otherwise, assume *nix lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 ;; esac ;; *-*-cygwin* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin ;; *-*-cygwin* ) lt_cv_to_host_file_cmd=func_convert_file_noop ;; * ) # otherwise, assume *nix lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin ;; esac ;; * ) # unhandled hosts (and "normal" native builds) lt_cv_to_host_file_cmd=func_convert_file_noop ;; esac ]) to_host_file_cmd=$lt_cv_to_host_file_cmd AC_MSG_RESULT([$lt_cv_to_host_file_cmd]) _LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd], [0], [convert $build file names to $host format])dnl AC_MSG_CHECKING([how to convert $build file names to toolchain format]) AC_CACHE_VAL(lt_cv_to_tool_file_cmd, [#assume ordinary cross tools, or native build. lt_cv_to_tool_file_cmd=func_convert_file_noop case $host in *-*-mingw* ) case $build in *-*-mingw* ) # actually msys lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 ;; esac ;; esac ]) to_tool_file_cmd=$lt_cv_to_tool_file_cmd AC_MSG_RESULT([$lt_cv_to_tool_file_cmd]) _LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd], [0], [convert $build files to toolchain format])dnl ])# _LT_PATH_CONVERSION_FUNCTIONS connman-ui-0_20150622+dfsg.orig/m4/intlmacosx.m40000644000175000017500000000457512541725135017533 0ustar nicknick# intlmacosx.m4 serial 3 (gettext-0.18) dnl Copyright (C) 2004-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl dnl This file can can be used in projects which are not available under dnl the GNU General Public License or the GNU Library General Public dnl License but which still want to provide support for the GNU gettext dnl functionality. dnl Please note that the actual code of the GNU gettext library is covered dnl by the GNU Library General Public License, and the rest of the GNU dnl gettext package package is covered by the GNU General Public License. dnl They are *not* in the public domain. dnl Checks for special options needed on MacOS X. dnl Defines INTL_MACOSX_LIBS. AC_DEFUN([gt_INTL_MACOSX], [ dnl Check for API introduced in MacOS X 10.2. AC_CACHE_CHECK([for CFPreferencesCopyAppValue], [gt_cv_func_CFPreferencesCopyAppValue], [gt_save_LIBS="$LIBS" LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" AC_TRY_LINK([#include ], [CFPreferencesCopyAppValue(NULL, NULL)], [gt_cv_func_CFPreferencesCopyAppValue=yes], [gt_cv_func_CFPreferencesCopyAppValue=no]) LIBS="$gt_save_LIBS"]) if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then AC_DEFINE([HAVE_CFPREFERENCESCOPYAPPVALUE], [1], [Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in the CoreFoundation framework.]) fi dnl Check for API introduced in MacOS X 10.3. AC_CACHE_CHECK([for CFLocaleCopyCurrent], [gt_cv_func_CFLocaleCopyCurrent], [gt_save_LIBS="$LIBS" LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" AC_TRY_LINK([#include ], [CFLocaleCopyCurrent();], [gt_cv_func_CFLocaleCopyCurrent=yes], [gt_cv_func_CFLocaleCopyCurrent=no]) LIBS="$gt_save_LIBS"]) if test $gt_cv_func_CFLocaleCopyCurrent = yes; then AC_DEFINE([HAVE_CFLOCALECOPYCURRENT], [1], [Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the CoreFoundation framework.]) fi INTL_MACOSX_LIBS= if test $gt_cv_func_CFPreferencesCopyAppValue = yes || test $gt_cv_func_CFLocaleCopyCurrent = yes; then INTL_MACOSX_LIBS="-Wl,-framework -Wl,CoreFoundation" fi AC_SUBST([INTL_MACOSX_LIBS]) ]) connman-ui-0_20150622+dfsg.orig/m4/lib-link.m40000644000175000017500000010020212541725135017033 0ustar nicknick# lib-link.m4 serial 21 (gettext-0.18) dnl Copyright (C) 2001-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. AC_PREREQ([2.54]) dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and dnl the libraries corresponding to explicit and implicit dependencies. dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and dnl augments the CPPFLAGS variable. dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem. AC_DEFUN([AC_LIB_LINKFLAGS], [ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) AC_REQUIRE([AC_LIB_RPATH]) pushdef([Name],[translit([$1],[./-], [___])]) pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [ AC_LIB_LINKFLAGS_BODY([$1], [$2]) ac_cv_lib[]Name[]_libs="$LIB[]NAME" ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME" ac_cv_lib[]Name[]_cppflags="$INC[]NAME" ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX" ]) LIB[]NAME="$ac_cv_lib[]Name[]_libs" LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs" INC[]NAME="$ac_cv_lib[]Name[]_cppflags" LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix" AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) AC_SUBST([LIB]NAME) AC_SUBST([LTLIB]NAME) AC_SUBST([LIB]NAME[_PREFIX]) dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the dnl results of this search when this library appears as a dependency. HAVE_LIB[]NAME=yes popdef([NAME]) popdef([Name]) ]) dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode, [missing-message]) dnl searches for libname and the libraries corresponding to explicit and dnl implicit dependencies, together with the specified include files and dnl the ability to compile and link the specified testcode. The missing-message dnl defaults to 'no' and may contain additional hints for the user. dnl If found, it sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} dnl and LTLIB${NAME} variables and augments the CPPFLAGS variable, and dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty. dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem. AC_DEFUN([AC_LIB_HAVE_LINKFLAGS], [ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) AC_REQUIRE([AC_LIB_RPATH]) pushdef([Name],[translit([$1],[./-], [___])]) pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME dnl accordingly. AC_LIB_LINKFLAGS_BODY([$1], [$2]) dnl Add $INC[]NAME to CPPFLAGS before performing the following checks, dnl because if the user has installed lib[]Name and not disabled its use dnl via --without-lib[]Name-prefix, he wants to use it. ac_save_CPPFLAGS="$CPPFLAGS" AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [ ac_save_LIBS="$LIBS" dnl If $LIB[]NAME contains some -l options, add it to the end of LIBS, dnl because these -l options might require -L options that are present in dnl LIBS. -l options benefit only from the -L options listed before it. dnl Otherwise, add it to the front of LIBS, because it may be a static dnl library that depends on another static library that is present in LIBS. dnl Static libraries benefit only from the static libraries listed after dnl it. case " $LIB[]NAME" in *" -l"*) LIBS="$LIBS $LIB[]NAME" ;; *) LIBS="$LIB[]NAME $LIBS" ;; esac AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name='m4_if([$5], [], [no], [[$5]])']) LIBS="$ac_save_LIBS" ]) if test "$ac_cv_lib[]Name" = yes; then HAVE_LIB[]NAME=yes AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the lib][$1 library.]) AC_MSG_CHECKING([how to link with lib[]$1]) AC_MSG_RESULT([$LIB[]NAME]) else HAVE_LIB[]NAME=no dnl If $LIB[]NAME didn't lead to a usable library, we don't need dnl $INC[]NAME either. CPPFLAGS="$ac_save_CPPFLAGS" LIB[]NAME= LTLIB[]NAME= LIB[]NAME[]_PREFIX= fi AC_SUBST([HAVE_LIB]NAME) AC_SUBST([LIB]NAME) AC_SUBST([LTLIB]NAME) AC_SUBST([LIB]NAME[_PREFIX]) popdef([NAME]) popdef([Name]) ]) dnl Determine the platform dependent parameters needed to use rpath: dnl acl_libext, dnl acl_shlibext, dnl acl_hardcode_libdir_flag_spec, dnl acl_hardcode_libdir_separator, dnl acl_hardcode_direct, dnl acl_hardcode_minus_L. AC_DEFUN([AC_LIB_RPATH], [ dnl Tell automake >= 1.10 to complain if config.rpath is missing. m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])]) AC_REQUIRE([AC_PROG_CC]) dnl we use $CC, $GCC, $LDFLAGS AC_REQUIRE([AC_LIB_PROG_LD]) dnl we use $LD, $with_gnu_ld AC_REQUIRE([AC_CANONICAL_HOST]) dnl we use $host AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir AC_CACHE_CHECK([for shared library run path origin], [acl_cv_rpath], [ CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \ ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh . ./conftest.sh rm -f ./conftest.sh acl_cv_rpath=done ]) wl="$acl_cv_wl" acl_libext="$acl_cv_libext" acl_shlibext="$acl_cv_shlibext" acl_libname_spec="$acl_cv_libname_spec" acl_library_names_spec="$acl_cv_library_names_spec" acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec" acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator" acl_hardcode_direct="$acl_cv_hardcode_direct" acl_hardcode_minus_L="$acl_cv_hardcode_minus_L" dnl Determine whether the user wants rpath handling at all. AC_ARG_ENABLE([rpath], [ --disable-rpath do not hardcode runtime library paths], :, enable_rpath=yes) ]) dnl AC_LIB_FROMPACKAGE(name, package) dnl declares that libname comes from the given package. The configure file dnl will then not have a --with-libname-prefix option but a dnl --with-package-prefix option. Several libraries can come from the same dnl package. This declaration must occur before an AC_LIB_LINKFLAGS or similar dnl macro call that searches for libname. AC_DEFUN([AC_LIB_FROMPACKAGE], [ pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) define([acl_frompackage_]NAME, [$2]) popdef([NAME]) pushdef([PACK],[$2]) pushdef([PACKUP],[translit(PACK,[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) define([acl_libsinpackage_]PACKUP, m4_ifdef([acl_libsinpackage_]PACKUP, [acl_libsinpackage_]PACKUP[[, ]],)[lib$1]) popdef([PACKUP]) popdef([PACK]) ]) dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and dnl the libraries corresponding to explicit and implicit dependencies. dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables. dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem. AC_DEFUN([AC_LIB_LINKFLAGS_BODY], [ AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) pushdef([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])]) pushdef([PACKUP],[translit(PACK,[abcdefghijklmnopqrstuvwxyz./-], [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])]) pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])]) dnl Autoconf >= 2.61 supports dots in --with options. pushdef([P_A_C_K],[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]),[2.61]),[-1],[translit(PACK,[.],[_])],PACK)]) dnl By default, look in $includedir and $libdir. use_additional=yes AC_LIB_WITH_FINAL_PREFIX([ eval additional_includedir=\"$includedir\" eval additional_libdir=\"$libdir\" ]) AC_ARG_WITH(P_A_C_K[-prefix], [[ --with-]]P_A_C_K[[-prefix[=DIR] search for ]PACKLIBS[ in DIR/include and DIR/lib --without-]]P_A_C_K[[-prefix don't search for ]PACKLIBS[ in includedir and libdir]], [ if test "X$withval" = "Xno"; then use_additional=no else if test "X$withval" = "X"; then AC_LIB_WITH_FINAL_PREFIX([ eval additional_includedir=\"$includedir\" eval additional_libdir=\"$libdir\" ]) else additional_includedir="$withval/include" additional_libdir="$withval/$acl_libdirstem" if test "$acl_libdirstem2" != "$acl_libdirstem" \ && ! test -d "$withval/$acl_libdirstem"; then additional_libdir="$withval/$acl_libdirstem2" fi fi fi ]) dnl Search the library and its dependencies in $additional_libdir and dnl $LDFLAGS. Using breadth-first-seach. LIB[]NAME= LTLIB[]NAME= INC[]NAME= LIB[]NAME[]_PREFIX= dnl HAVE_LIB${NAME} is an indicator that LIB${NAME}, LTLIB${NAME} have been dnl computed. So it has to be reset here. HAVE_LIB[]NAME= rpathdirs= ltrpathdirs= names_already_handled= names_next_round='$1 $2' while test -n "$names_next_round"; do names_this_round="$names_next_round" names_next_round= for name in $names_this_round; do already_handled= for n in $names_already_handled; do if test "$n" = "$name"; then already_handled=yes break fi done if test -z "$already_handled"; then names_already_handled="$names_already_handled $name" dnl See if it was already located by an earlier AC_LIB_LINKFLAGS dnl or AC_LIB_HAVE_LINKFLAGS call. uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'` eval value=\"\$HAVE_LIB$uppername\" if test -n "$value"; then if test "$value" = yes; then eval value=\"\$LIB$uppername\" test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value" eval value=\"\$LTLIB$uppername\" test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value" else dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined dnl that this library doesn't exist. So just drop it. : fi else dnl Search the library lib$name in $additional_libdir and $LDFLAGS dnl and the already constructed $LIBNAME/$LTLIBNAME. found_dir= found_la= found_so= found_a= eval libname=\"$acl_libname_spec\" # typically: libname=lib$name if test -n "$acl_shlibext"; then shrext=".$acl_shlibext" # typically: shrext=.so else shrext= fi if test $use_additional = yes; then dir="$additional_libdir" dnl The same code as in the loop below: dnl First look for a shared library. if test -n "$acl_shlibext"; then if test -f "$dir/$libname$shrext"; then found_dir="$dir" found_so="$dir/$libname$shrext" else if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then ver=`(cd "$dir" && \ for f in "$libname$shrext".*; do echo "$f"; done \ | sed -e "s,^$libname$shrext\\\\.,," \ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ | sed 1q ) 2>/dev/null` if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then found_dir="$dir" found_so="$dir/$libname$shrext.$ver" fi else eval library_names=\"$acl_library_names_spec\" for f in $library_names; do if test -f "$dir/$f"; then found_dir="$dir" found_so="$dir/$f" break fi done fi fi fi dnl Then look for a static library. if test "X$found_dir" = "X"; then if test -f "$dir/$libname.$acl_libext"; then found_dir="$dir" found_a="$dir/$libname.$acl_libext" fi fi if test "X$found_dir" != "X"; then if test -f "$dir/$libname.la"; then found_la="$dir/$libname.la" fi fi fi if test "X$found_dir" = "X"; then for x in $LDFLAGS $LTLIB[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) case "$x" in -L*) dir=`echo "X$x" | sed -e 's/^X-L//'` dnl First look for a shared library. if test -n "$acl_shlibext"; then if test -f "$dir/$libname$shrext"; then found_dir="$dir" found_so="$dir/$libname$shrext" else if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then ver=`(cd "$dir" && \ for f in "$libname$shrext".*; do echo "$f"; done \ | sed -e "s,^$libname$shrext\\\\.,," \ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ | sed 1q ) 2>/dev/null` if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then found_dir="$dir" found_so="$dir/$libname$shrext.$ver" fi else eval library_names=\"$acl_library_names_spec\" for f in $library_names; do if test -f "$dir/$f"; then found_dir="$dir" found_so="$dir/$f" break fi done fi fi fi dnl Then look for a static library. if test "X$found_dir" = "X"; then if test -f "$dir/$libname.$acl_libext"; then found_dir="$dir" found_a="$dir/$libname.$acl_libext" fi fi if test "X$found_dir" != "X"; then if test -f "$dir/$libname.la"; then found_la="$dir/$libname.la" fi fi ;; esac if test "X$found_dir" != "X"; then break fi done fi if test "X$found_dir" != "X"; then dnl Found the library. LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name" if test "X$found_so" != "X"; then dnl Linking with a shared library. We attempt to hardcode its dnl directory into the executable's runpath, unless it's the dnl standard /usr/lib. if test "$enable_rpath" = no \ || test "X$found_dir" = "X/usr/$acl_libdirstem" \ || test "X$found_dir" = "X/usr/$acl_libdirstem2"; then dnl No hardcoding is needed. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" else dnl Use an explicit option to hardcode DIR into the resulting dnl binary. dnl Potentially add DIR to ltrpathdirs. dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. haveit= for x in $ltrpathdirs; do if test "X$x" = "X$found_dir"; then haveit=yes break fi done if test -z "$haveit"; then ltrpathdirs="$ltrpathdirs $found_dir" fi dnl The hardcoding into $LIBNAME is system dependent. if test "$acl_hardcode_direct" = yes; then dnl Using DIR/libNAME.so during linking hardcodes DIR into the dnl resulting binary. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" else if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then dnl Use an explicit option to hardcode DIR into the resulting dnl binary. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" dnl Potentially add DIR to rpathdirs. dnl The rpathdirs will be appended to $LIBNAME at the end. haveit= for x in $rpathdirs; do if test "X$x" = "X$found_dir"; then haveit=yes break fi done if test -z "$haveit"; then rpathdirs="$rpathdirs $found_dir" fi else dnl Rely on "-L$found_dir". dnl But don't add it if it's already contained in the LDFLAGS dnl or the already constructed $LIBNAME haveit= for x in $LDFLAGS $LIB[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-L$found_dir"; then haveit=yes break fi done if test -z "$haveit"; then LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir" fi if test "$acl_hardcode_minus_L" != no; then dnl FIXME: Not sure whether we should use dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" dnl here. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" else dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH dnl here, because this doesn't fit in flags passed to the dnl compiler. So give up. No hardcoding. This affects only dnl very old systems. dnl FIXME: Not sure whether we should use dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" dnl here. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" fi fi fi fi else if test "X$found_a" != "X"; then dnl Linking with a static library. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a" else dnl We shouldn't come here, but anyway it's good to have a dnl fallback. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name" fi fi dnl Assume the include files are nearby. additional_includedir= case "$found_dir" in */$acl_libdirstem | */$acl_libdirstem/) basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'` if test "$name" = '$1'; then LIB[]NAME[]_PREFIX="$basedir" fi additional_includedir="$basedir/include" ;; */$acl_libdirstem2 | */$acl_libdirstem2/) basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'` if test "$name" = '$1'; then LIB[]NAME[]_PREFIX="$basedir" fi additional_includedir="$basedir/include" ;; esac if test "X$additional_includedir" != "X"; then dnl Potentially add $additional_includedir to $INCNAME. dnl But don't add it dnl 1. if it's the standard /usr/include, dnl 2. if it's /usr/local/include and we are using GCC on Linux, dnl 3. if it's already present in $CPPFLAGS or the already dnl constructed $INCNAME, dnl 4. if it doesn't exist as a directory. if test "X$additional_includedir" != "X/usr/include"; then haveit= if test "X$additional_includedir" = "X/usr/local/include"; then if test -n "$GCC"; then case $host_os in linux* | gnu* | k*bsd*-gnu) haveit=yes;; esac fi fi if test -z "$haveit"; then for x in $CPPFLAGS $INC[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-I$additional_includedir"; then haveit=yes break fi done if test -z "$haveit"; then if test -d "$additional_includedir"; then dnl Really add $additional_includedir to $INCNAME. INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir" fi fi fi fi fi dnl Look for dependencies. if test -n "$found_la"; then dnl Read the .la file. It defines the variables dnl dlname, library_names, old_library, dependency_libs, current, dnl age, revision, installed, dlopen, dlpreopen, libdir. save_libdir="$libdir" case "$found_la" in */* | *\\*) . "$found_la" ;; *) . "./$found_la" ;; esac libdir="$save_libdir" dnl We use only dependency_libs. for dep in $dependency_libs; do case "$dep" in -L*) additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'` dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME. dnl But don't add it dnl 1. if it's the standard /usr/lib, dnl 2. if it's /usr/local/lib and we are using GCC on Linux, dnl 3. if it's already present in $LDFLAGS or the already dnl constructed $LIBNAME, dnl 4. if it doesn't exist as a directory. if test "X$additional_libdir" != "X/usr/$acl_libdirstem" \ && test "X$additional_libdir" != "X/usr/$acl_libdirstem2"; then haveit= if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem" \ || test "X$additional_libdir" = "X/usr/local/$acl_libdirstem2"; then if test -n "$GCC"; then case $host_os in linux* | gnu* | k*bsd*-gnu) haveit=yes;; esac fi fi if test -z "$haveit"; then haveit= for x in $LDFLAGS $LIB[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-L$additional_libdir"; then haveit=yes break fi done if test -z "$haveit"; then if test -d "$additional_libdir"; then dnl Really add $additional_libdir to $LIBNAME. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir" fi fi haveit= for x in $LDFLAGS $LTLIB[]NAME; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-L$additional_libdir"; then haveit=yes break fi done if test -z "$haveit"; then if test -d "$additional_libdir"; then dnl Really add $additional_libdir to $LTLIBNAME. LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir" fi fi fi fi ;; -R*) dir=`echo "X$dep" | sed -e 's/^X-R//'` if test "$enable_rpath" != no; then dnl Potentially add DIR to rpathdirs. dnl The rpathdirs will be appended to $LIBNAME at the end. haveit= for x in $rpathdirs; do if test "X$x" = "X$dir"; then haveit=yes break fi done if test -z "$haveit"; then rpathdirs="$rpathdirs $dir" fi dnl Potentially add DIR to ltrpathdirs. dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. haveit= for x in $ltrpathdirs; do if test "X$x" = "X$dir"; then haveit=yes break fi done if test -z "$haveit"; then ltrpathdirs="$ltrpathdirs $dir" fi fi ;; -l*) dnl Handle this in the next round. names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'` ;; *.la) dnl Handle this in the next round. Throw away the .la's dnl directory; it is already contained in a preceding -L dnl option. names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` ;; *) dnl Most likely an immediate library name. LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep" LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep" ;; esac done fi else dnl Didn't find the library; assume it is in the system directories dnl known to the linker and runtime loader. (All the system dnl directories known to the linker should also be known to the dnl runtime loader, otherwise the system is severely misconfigured.) LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name" fi fi fi done done if test "X$rpathdirs" != "X"; then if test -n "$acl_hardcode_libdir_separator"; then dnl Weird platform: only the last -rpath option counts, the user must dnl pass all path elements in one option. We can arrange that for a dnl single library, but not when more than one $LIBNAMEs are used. alldirs= for found_dir in $rpathdirs; do alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir" done dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl. acl_save_libdir="$libdir" libdir="$alldirs" eval flag=\"$acl_hardcode_libdir_flag_spec\" libdir="$acl_save_libdir" LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" else dnl The -rpath options are cumulative. for found_dir in $rpathdirs; do acl_save_libdir="$libdir" libdir="$found_dir" eval flag=\"$acl_hardcode_libdir_flag_spec\" libdir="$acl_save_libdir" LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" done fi fi if test "X$ltrpathdirs" != "X"; then dnl When using libtool, the option that works for both libraries and dnl executables is -R. The -R options are cumulative. for found_dir in $ltrpathdirs; do LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir" done fi popdef([P_A_C_K]) popdef([PACKLIBS]) popdef([PACKUP]) popdef([PACK]) popdef([NAME]) ]) dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR, dnl unless already present in VAR. dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes dnl contains two or three consecutive elements that belong together. AC_DEFUN([AC_LIB_APPENDTOVAR], [ for element in [$2]; do haveit= for x in $[$1]; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X$element"; then haveit=yes break fi done if test -z "$haveit"; then [$1]="${[$1]}${[$1]:+ }$element" fi done ]) dnl For those cases where a variable contains several -L and -l options dnl referring to unknown libraries and directories, this macro determines the dnl necessary additional linker options for the runtime path. dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL]) dnl sets LDADDVAR to linker options needed together with LIBSVALUE. dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed, dnl otherwise linking without libtool is assumed. AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS], [ AC_REQUIRE([AC_LIB_RPATH]) AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) $1= if test "$enable_rpath" != no; then if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then dnl Use an explicit option to hardcode directories into the resulting dnl binary. rpathdirs= next= for opt in $2; do if test -n "$next"; then dir="$next" dnl No need to hardcode the standard /usr/lib. if test "X$dir" != "X/usr/$acl_libdirstem" \ && test "X$dir" != "X/usr/$acl_libdirstem2"; then rpathdirs="$rpathdirs $dir" fi next= else case $opt in -L) next=yes ;; -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'` dnl No need to hardcode the standard /usr/lib. if test "X$dir" != "X/usr/$acl_libdirstem" \ && test "X$dir" != "X/usr/$acl_libdirstem2"; then rpathdirs="$rpathdirs $dir" fi next= ;; *) next= ;; esac fi done if test "X$rpathdirs" != "X"; then if test -n ""$3""; then dnl libtool is used for linking. Use -R options. for dir in $rpathdirs; do $1="${$1}${$1:+ }-R$dir" done else dnl The linker is used for linking directly. if test -n "$acl_hardcode_libdir_separator"; then dnl Weird platform: only the last -rpath option counts, the user dnl must pass all path elements in one option. alldirs= for dir in $rpathdirs; do alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir" done acl_save_libdir="$libdir" libdir="$alldirs" eval flag=\"$acl_hardcode_libdir_flag_spec\" libdir="$acl_save_libdir" $1="$flag" else dnl The -rpath options are cumulative. for dir in $rpathdirs; do acl_save_libdir="$libdir" libdir="$dir" eval flag=\"$acl_hardcode_libdir_flag_spec\" libdir="$acl_save_libdir" $1="${$1}${$1:+ }$flag" done fi fi fi fi fi AC_SUBST([$1]) ]) connman-ui-0_20150622+dfsg.orig/m4/threadlib.m40000644000175000017500000003237712541725135017311 0ustar nicknick# threadlib.m4 serial 5 (gettext-0.18) dnl Copyright (C) 2005-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. dnl gl_THREADLIB dnl ------------ dnl Tests for a multithreading library to be used. dnl Defines at most one of the macros USE_POSIX_THREADS, USE_SOLARIS_THREADS, dnl USE_PTH_THREADS, USE_WIN32_THREADS dnl Sets the variables LIBTHREAD and LTLIBTHREAD to the linker options for use dnl in a Makefile (LIBTHREAD for use without libtool, LTLIBTHREAD for use with dnl libtool). dnl Sets the variables LIBMULTITHREAD and LTLIBMULTITHREAD similarly, for dnl programs that really need multithread functionality. The difference dnl between LIBTHREAD and LIBMULTITHREAD is that on platforms supporting weak dnl symbols, typically LIBTHREAD="" whereas LIBMULTITHREAD="-lpthread". dnl Adds to CPPFLAGS the flag -D_REENTRANT or -D_THREAD_SAFE if needed for dnl multithread-safe programs. AC_DEFUN([gl_THREADLIB_EARLY], [ AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) ]) dnl The guts of gl_THREADLIB_EARLY. Needs to be expanded only once. AC_DEFUN([gl_THREADLIB_EARLY_BODY], [ dnl Ordering constraints: This macro modifies CPPFLAGS in a way that dnl influences the result of the autoconf tests that test for *_unlocked dnl declarations, on AIX 5 at least. Therefore it must come early. AC_BEFORE([$0], [gl_FUNC_GLIBC_UNLOCKED_IO])dnl AC_BEFORE([$0], [gl_ARGP])dnl AC_REQUIRE([AC_CANONICAL_HOST]) dnl _GNU_SOURCE is needed for pthread_rwlock_t on glibc systems. dnl AC_USE_SYSTEM_EXTENSIONS was introduced in autoconf 2.60 and obsoletes dnl AC_GNU_SOURCE. m4_ifdef([AC_USE_SYSTEM_EXTENSIONS], [AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])], [AC_REQUIRE([AC_GNU_SOURCE])]) dnl Check for multithreading. m4_divert_text([DEFAULTS], [gl_use_threads_default=]) AC_ARG_ENABLE([threads], AC_HELP_STRING([--enable-threads={posix|solaris|pth|win32}], [specify multithreading API]) AC_HELP_STRING([--disable-threads], [build without multithread safety]), [gl_use_threads=$enableval], [if test -n "$gl_use_threads_default"; then gl_use_threads="$gl_use_threads_default" else changequote(,)dnl case "$host_os" in dnl Disable multithreading by default on OSF/1, because it interferes dnl with fork()/exec(): When msgexec is linked with -lpthread, its dnl child process gets an endless segmentation fault inside execvp(). dnl Disable multithreading by default on Cygwin 1.5.x, because it has dnl bugs that lead to endless loops or crashes. See dnl . osf*) gl_use_threads=no ;; cygwin*) case `uname -r` in 1.[0-5].*) gl_use_threads=no ;; *) gl_use_threads=yes ;; esac ;; *) gl_use_threads=yes ;; esac changequote([,])dnl fi ]) if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then # For using : case "$host_os" in osf*) # On OSF/1, the compiler needs the flag -D_REENTRANT so that it # groks . cc also understands the flag -pthread, but # we don't use it because 1. gcc-2.95 doesn't understand -pthread, # 2. putting a flag into CPPFLAGS that has an effect on the linker # causes the AC_TRY_LINK test below to succeed unexpectedly, # leading to wrong values of LIBTHREAD and LTLIBTHREAD. CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;; esac # Some systems optimize for single-threaded programs by default, and # need special flags to disable these optimizations. For example, the # definition of 'errno' in . case "$host_os" in aix* | freebsd*) CPPFLAGS="$CPPFLAGS -D_THREAD_SAFE" ;; solaris*) CPPFLAGS="$CPPFLAGS -D_REENTRANT" ;; esac fi ]) dnl The guts of gl_THREADLIB. Needs to be expanded only once. AC_DEFUN([gl_THREADLIB_BODY], [ AC_REQUIRE([gl_THREADLIB_EARLY_BODY]) gl_threads_api=none LIBTHREAD= LTLIBTHREAD= LIBMULTITHREAD= LTLIBMULTITHREAD= if test "$gl_use_threads" != no; then dnl Check whether the compiler and linker support weak declarations. AC_CACHE_CHECK([whether imported symbols can be declared weak], [gl_cv_have_weak], [gl_cv_have_weak=no dnl First, test whether the compiler accepts it syntactically. AC_TRY_LINK([extern void xyzzy (); #pragma weak xyzzy], [xyzzy();], [gl_cv_have_weak=maybe]) if test $gl_cv_have_weak = maybe; then dnl Second, test whether it actually works. On Cygwin 1.7.2, with dnl gcc 4.3, symbols declared weak always evaluate to the address 0. AC_TRY_RUN([ #include #pragma weak fputs int main () { return (fputs == NULL); }], [gl_cv_have_weak=yes], [gl_cv_have_weak=no], [dnl When cross-compiling, assume that only ELF platforms support dnl weak symbols. AC_EGREP_CPP([Extensible Linking Format], [#ifdef __ELF__ Extensible Linking Format #endif ], [gl_cv_have_weak="guessing yes"], [gl_cv_have_weak="guessing no"]) ]) fi ]) if test "$gl_use_threads" = yes || test "$gl_use_threads" = posix; then # On OSF/1, the compiler needs the flag -pthread or -D_REENTRANT so that # it groks . It's added above, in gl_THREADLIB_EARLY_BODY. AC_CHECK_HEADER([pthread.h], [gl_have_pthread_h=yes], [gl_have_pthread_h=no]) if test "$gl_have_pthread_h" = yes; then # Other possible tests: # -lpthreads (FSU threads, PCthreads) # -lgthreads gl_have_pthread= # Test whether both pthread_mutex_lock and pthread_mutexattr_init exist # in libc. IRIX 6.5 has the first one in both libc and libpthread, but # the second one only in libpthread, and lock.c needs it. AC_TRY_LINK([#include ], [pthread_mutex_lock((pthread_mutex_t*)0); pthread_mutexattr_init((pthread_mutexattr_t*)0);], [gl_have_pthread=yes]) # Test for libpthread by looking for pthread_kill. (Not pthread_self, # since it is defined as a macro on OSF/1.) if test -n "$gl_have_pthread"; then # The program links fine without libpthread. But it may actually # need to link with libpthread in order to create multiple threads. AC_CHECK_LIB([pthread], [pthread_kill], [LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread # On Solaris and HP-UX, most pthread functions exist also in libc. # Therefore pthread_in_use() needs to actually try to create a # thread: pthread_create from libc will fail, whereas # pthread_create will actually create a thread. case "$host_os" in solaris* | hpux*) AC_DEFINE([PTHREAD_IN_USE_DETECTION_HARD], [1], [Define if the pthread_in_use() detection is hard.]) esac ]) else # Some library is needed. Try libpthread and libc_r. AC_CHECK_LIB([pthread], [pthread_kill], [gl_have_pthread=yes LIBTHREAD=-lpthread LTLIBTHREAD=-lpthread LIBMULTITHREAD=-lpthread LTLIBMULTITHREAD=-lpthread]) if test -z "$gl_have_pthread"; then # For FreeBSD 4. AC_CHECK_LIB([c_r], [pthread_kill], [gl_have_pthread=yes LIBTHREAD=-lc_r LTLIBTHREAD=-lc_r LIBMULTITHREAD=-lc_r LTLIBMULTITHREAD=-lc_r]) fi fi if test -n "$gl_have_pthread"; then gl_threads_api=posix AC_DEFINE([USE_POSIX_THREADS], [1], [Define if the POSIX multithreading library can be used.]) if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then AC_DEFINE([USE_POSIX_THREADS_WEAK], [1], [Define if references to the POSIX multithreading library should be made weak.]) LIBTHREAD= LTLIBTHREAD= fi fi fi fi fi if test -z "$gl_have_pthread"; then if test "$gl_use_threads" = yes || test "$gl_use_threads" = solaris; then gl_have_solaristhread= gl_save_LIBS="$LIBS" LIBS="$LIBS -lthread" AC_TRY_LINK([#include #include ], [thr_self();], [gl_have_solaristhread=yes]) LIBS="$gl_save_LIBS" if test -n "$gl_have_solaristhread"; then gl_threads_api=solaris LIBTHREAD=-lthread LTLIBTHREAD=-lthread LIBMULTITHREAD="$LIBTHREAD" LTLIBMULTITHREAD="$LTLIBTHREAD" AC_DEFINE([USE_SOLARIS_THREADS], [1], [Define if the old Solaris multithreading library can be used.]) if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then AC_DEFINE([USE_SOLARIS_THREADS_WEAK], [1], [Define if references to the old Solaris multithreading library should be made weak.]) LIBTHREAD= LTLIBTHREAD= fi fi fi fi if test "$gl_use_threads" = pth; then gl_save_CPPFLAGS="$CPPFLAGS" AC_LIB_LINKFLAGS([pth]) gl_have_pth= gl_save_LIBS="$LIBS" LIBS="$LIBS -lpth" AC_TRY_LINK([#include ], [pth_self();], [gl_have_pth=yes]) LIBS="$gl_save_LIBS" if test -n "$gl_have_pth"; then gl_threads_api=pth LIBTHREAD="$LIBPTH" LTLIBTHREAD="$LTLIBPTH" LIBMULTITHREAD="$LIBTHREAD" LTLIBMULTITHREAD="$LTLIBTHREAD" AC_DEFINE([USE_PTH_THREADS], [1], [Define if the GNU Pth multithreading library can be used.]) if test -n "$LIBMULTITHREAD" || test -n "$LTLIBMULTITHREAD"; then if case "$gl_cv_have_weak" in *yes) true;; *) false;; esac; then AC_DEFINE([USE_PTH_THREADS_WEAK], [1], [Define if references to the GNU Pth multithreading library should be made weak.]) LIBTHREAD= LTLIBTHREAD= fi fi else CPPFLAGS="$gl_save_CPPFLAGS" fi fi if test -z "$gl_have_pthread"; then if test "$gl_use_threads" = yes || test "$gl_use_threads" = win32; then if { case "$host_os" in mingw*) true;; *) false;; esac }; then gl_threads_api=win32 AC_DEFINE([USE_WIN32_THREADS], [1], [Define if the Win32 multithreading API can be used.]) fi fi fi fi AC_MSG_CHECKING([for multithread API to use]) AC_MSG_RESULT([$gl_threads_api]) AC_SUBST([LIBTHREAD]) AC_SUBST([LTLIBTHREAD]) AC_SUBST([LIBMULTITHREAD]) AC_SUBST([LTLIBMULTITHREAD]) ]) AC_DEFUN([gl_THREADLIB], [ AC_REQUIRE([gl_THREADLIB_EARLY]) AC_REQUIRE([gl_THREADLIB_BODY]) ]) dnl gl_DISABLE_THREADS dnl ------------------ dnl Sets the gl_THREADLIB default so that threads are not used by default. dnl The user can still override it at installation time, by using the dnl configure option '--enable-threads'. AC_DEFUN([gl_DISABLE_THREADS], [ m4_divert_text([INIT_PREPARE], [gl_use_threads_default=no]) ]) dnl Survey of platforms: dnl dnl Platform Available Compiler Supports test-lock dnl flavours option weak result dnl --------------- --------- --------- -------- --------- dnl Linux 2.4/glibc posix -lpthread Y OK dnl dnl GNU Hurd/glibc posix dnl dnl FreeBSD 5.3 posix -lc_r Y dnl posix -lkse ? Y dnl posix -lpthread ? Y dnl posix -lthr Y dnl dnl FreeBSD 5.2 posix -lc_r Y dnl posix -lkse Y dnl posix -lthr Y dnl dnl FreeBSD 4.0,4.10 posix -lc_r Y OK dnl dnl NetBSD 1.6 -- dnl dnl OpenBSD 3.4 posix -lpthread Y OK dnl dnl MacOS X 10.[123] posix -lpthread Y OK dnl dnl Solaris 7,8,9 posix -lpthread Y Sol 7,8: 0.0; Sol 9: OK dnl solaris -lthread Y Sol 7,8: 0.0; Sol 9: OK dnl dnl HP-UX 11 posix -lpthread N (cc) OK dnl Y (gcc) dnl dnl IRIX 6.5 posix -lpthread Y 0.5 dnl dnl AIX 4.3,5.1 posix -lpthread N AIX 4: 0.5; AIX 5: OK dnl dnl OSF/1 4.0,5.1 posix -pthread (cc) N OK dnl -lpthread (gcc) Y dnl dnl Cygwin posix -lpthread Y OK dnl dnl Any of the above pth -lpth 0.0 dnl dnl Mingw win32 N OK dnl dnl BeOS 5 -- dnl dnl The test-lock result shows what happens if in test-lock.c EXPLICIT_YIELD is dnl turned off: dnl OK if all three tests terminate OK, dnl 0.5 if the first test terminates OK but the second one loops endlessly, dnl 0.0 if the first test already loops endlessly. connman-ui-0_20150622+dfsg.orig/m4/wchar_t.m40000644000175000017500000000135312541725135016770 0ustar nicknick# wchar_t.m4 serial 3 (gettext-0.18) dnl Copyright (C) 2002-2003, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. dnl Test whether has the 'wchar_t' type. dnl Prerequisite: AC_PROG_CC AC_DEFUN([gt_TYPE_WCHAR_T], [ AC_CACHE_CHECK([for wchar_t], [gt_cv_c_wchar_t], [AC_TRY_COMPILE([#include wchar_t foo = (wchar_t)'\0';], , [gt_cv_c_wchar_t=yes], [gt_cv_c_wchar_t=no])]) if test $gt_cv_c_wchar_t = yes; then AC_DEFINE([HAVE_WCHAR_T], [1], [Define if you have the 'wchar_t' type.]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/wint_t.m40000644000175000017500000000172612541725135016651 0ustar nicknick# wint_t.m4 serial 4 (gettext-0.18) dnl Copyright (C) 2003, 2007-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. dnl Test whether has the 'wint_t' type. dnl Prerequisite: AC_PROG_CC AC_DEFUN([gt_TYPE_WINT_T], [ AC_CACHE_CHECK([for wint_t], [gt_cv_c_wint_t], [AC_TRY_COMPILE([ /* Tru64 with Desktop Toolkit C has a bug: must be included before . BSD/OS 4.0.1 has a bug: , and must be included before . */ #include #include #include #include wint_t foo = (wchar_t)'\0';], , [gt_cv_c_wint_t=yes], [gt_cv_c_wint_t=no])]) if test $gt_cv_c_wint_t = yes; then AC_DEFINE([HAVE_WINT_T], [1], [Define if you have the 'wint_t' type.]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/glibc21.m40000644000175000017500000000152612541725135016566 0ustar nicknick# glibc21.m4 serial 4 dnl Copyright (C) 2000-2002, 2004, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. # Test for the GNU C Library, version 2.1 or newer. # From Bruno Haible. AC_DEFUN([gl_GLIBC21], [ AC_CACHE_CHECK([whether we are using the GNU C Library 2.1 or newer], [ac_cv_gnu_library_2_1], [AC_EGREP_CPP([Lucky GNU user], [ #include #ifdef __GNU_LIBRARY__ #if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1) || (__GLIBC__ > 2) Lucky GNU user #endif #endif ], [ac_cv_gnu_library_2_1=yes], [ac_cv_gnu_library_2_1=no]) ] ) AC_SUBST([GLIBC21]) GLIBC21="$ac_cv_gnu_library_2_1" ] ) connman-ui-0_20150622+dfsg.orig/m4/nls.m40000644000175000017500000000231512541725135016134 0ustar nicknick# nls.m4 serial 5 (gettext-0.18) dnl Copyright (C) 1995-2003, 2005-2006, 2008-2010 Free Software Foundation, dnl Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl dnl This file can can be used in projects which are not available under dnl the GNU General Public License or the GNU Library General Public dnl License but which still want to provide support for the GNU gettext dnl functionality. dnl Please note that the actual code of the GNU gettext library is covered dnl by the GNU Library General Public License, and the rest of the GNU dnl gettext package package is covered by the GNU General Public License. dnl They are *not* in the public domain. dnl Authors: dnl Ulrich Drepper , 1995-2000. dnl Bruno Haible , 2000-2003. AC_PREREQ([2.50]) AC_DEFUN([AM_NLS], [ AC_MSG_CHECKING([whether NLS is requested]) dnl Default is enabled NLS AC_ARG_ENABLE([nls], [ --disable-nls do not use Native Language Support], USE_NLS=$enableval, USE_NLS=yes) AC_MSG_RESULT([$USE_NLS]) AC_SUBST([USE_NLS]) ]) connman-ui-0_20150622+dfsg.orig/m4/gettext.m40000644000175000017500000003513212541725135017027 0ustar nicknick# gettext.m4 serial 63 (gettext-0.18) dnl Copyright (C) 1995-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl dnl This file can can be used in projects which are not available under dnl the GNU General Public License or the GNU Library General Public dnl License but which still want to provide support for the GNU gettext dnl functionality. dnl Please note that the actual code of the GNU gettext library is covered dnl by the GNU Library General Public License, and the rest of the GNU dnl gettext package package is covered by the GNU General Public License. dnl They are *not* in the public domain. dnl Authors: dnl Ulrich Drepper , 1995-2000. dnl Bruno Haible , 2000-2006, 2008-2010. dnl Macro to add for using GNU gettext. dnl Usage: AM_GNU_GETTEXT([INTLSYMBOL], [NEEDSYMBOL], [INTLDIR]). dnl INTLSYMBOL can be one of 'external', 'no-libtool', 'use-libtool'. The dnl default (if it is not specified or empty) is 'no-libtool'. dnl INTLSYMBOL should be 'external' for packages with no intl directory, dnl and 'no-libtool' or 'use-libtool' for packages with an intl directory. dnl If INTLSYMBOL is 'use-libtool', then a libtool library dnl $(top_builddir)/intl/libintl.la will be created (shared and/or static, dnl depending on --{enable,disable}-{shared,static} and on the presence of dnl AM-DISABLE-SHARED). If INTLSYMBOL is 'no-libtool', a static library dnl $(top_builddir)/intl/libintl.a will be created. dnl If NEEDSYMBOL is specified and is 'need-ngettext', then GNU gettext dnl implementations (in libc or libintl) without the ngettext() function dnl will be ignored. If NEEDSYMBOL is specified and is dnl 'need-formatstring-macros', then GNU gettext implementations that don't dnl support the ISO C 99 formatstring macros will be ignored. dnl INTLDIR is used to find the intl libraries. If empty, dnl the value `$(top_builddir)/intl/' is used. dnl dnl The result of the configuration is one of three cases: dnl 1) GNU gettext, as included in the intl subdirectory, will be compiled dnl and used. dnl Catalog format: GNU --> install in $(datadir) dnl Catalog extension: .mo after installation, .gmo in source tree dnl 2) GNU gettext has been found in the system's C library. dnl Catalog format: GNU --> install in $(datadir) dnl Catalog extension: .mo after installation, .gmo in source tree dnl 3) No internationalization, always use English msgid. dnl Catalog format: none dnl Catalog extension: none dnl If INTLSYMBOL is 'external', only cases 2 and 3 can occur. dnl The use of .gmo is historical (it was needed to avoid overwriting the dnl GNU format catalogs when building on a platform with an X/Open gettext), dnl but we keep it in order not to force irrelevant filename changes on the dnl maintainers. dnl AC_DEFUN([AM_GNU_GETTEXT], [ dnl Argument checking. ifelse([$1], [], , [ifelse([$1], [external], , [ifelse([$1], [no-libtool], , [ifelse([$1], [use-libtool], , [errprint([ERROR: invalid first argument to AM_GNU_GETTEXT ])])])])]) ifelse(ifelse([$1], [], [old])[]ifelse([$1], [no-libtool], [old]), [old], [AC_DIAGNOSE([obsolete], [Use of AM_GNU_GETTEXT without [external] argument is deprecated.])]) ifelse([$2], [], , [ifelse([$2], [need-ngettext], , [ifelse([$2], [need-formatstring-macros], , [errprint([ERROR: invalid second argument to AM_GNU_GETTEXT ])])])]) define([gt_included_intl], ifelse([$1], [external], ifdef([AM_GNU_GETTEXT_][INTL_SUBDIR], [yes], [no]), [yes])) define([gt_libtool_suffix_prefix], ifelse([$1], [use-libtool], [l], [])) gt_NEEDS_INIT AM_GNU_GETTEXT_NEED([$2]) AC_REQUIRE([AM_PO_SUBDIRS])dnl ifelse(gt_included_intl, yes, [ AC_REQUIRE([AM_INTL_SUBDIR])dnl ]) dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) AC_REQUIRE([AC_LIB_RPATH]) dnl Sometimes libintl requires libiconv, so first search for libiconv. dnl Ideally we would do this search only after the dnl if test "$USE_NLS" = "yes"; then dnl if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then dnl tests. But if configure.in invokes AM_ICONV after AM_GNU_GETTEXT dnl the configure script would need to contain the same shell code dnl again, outside any 'if'. There are two solutions: dnl - Invoke AM_ICONV_LINKFLAGS_BODY here, outside any 'if'. dnl - Control the expansions in more detail using AC_PROVIDE_IFELSE. dnl Since AC_PROVIDE_IFELSE is only in autoconf >= 2.52 and not dnl documented, we avoid it. ifelse(gt_included_intl, yes, , [ AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) ]) dnl Sometimes, on MacOS X, libintl requires linking with CoreFoundation. gt_INTL_MACOSX dnl Set USE_NLS. AC_REQUIRE([AM_NLS]) ifelse(gt_included_intl, yes, [ BUILD_INCLUDED_LIBINTL=no USE_INCLUDED_LIBINTL=no ]) LIBINTL= LTLIBINTL= POSUB= dnl Add a version number to the cache macros. case " $gt_needs " in *" need-formatstring-macros "*) gt_api_version=3 ;; *" need-ngettext "*) gt_api_version=2 ;; *) gt_api_version=1 ;; esac gt_func_gnugettext_libc="gt_cv_func_gnugettext${gt_api_version}_libc" gt_func_gnugettext_libintl="gt_cv_func_gnugettext${gt_api_version}_libintl" dnl If we use NLS figure out what method if test "$USE_NLS" = "yes"; then gt_use_preinstalled_gnugettext=no ifelse(gt_included_intl, yes, [ AC_MSG_CHECKING([whether included gettext is requested]) AC_ARG_WITH([included-gettext], [ --with-included-gettext use the GNU gettext library included here], nls_cv_force_use_gnu_gettext=$withval, nls_cv_force_use_gnu_gettext=no) AC_MSG_RESULT([$nls_cv_force_use_gnu_gettext]) nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext" if test "$nls_cv_force_use_gnu_gettext" != "yes"; then ]) dnl User does not insist on using GNU NLS library. Figure out what dnl to use. If GNU gettext is available we use this. Else we have dnl to fall back to GNU NLS library. if test $gt_api_version -ge 3; then gt_revision_test_code=' #ifndef __GNU_GETTEXT_SUPPORTED_REVISION #define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) #endif changequote(,)dnl typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; changequote([,])dnl ' else gt_revision_test_code= fi if test $gt_api_version -ge 2; then gt_expression_test_code=' + * ngettext ("", "", 0)' else gt_expression_test_code= fi AC_CACHE_CHECK([for GNU gettext in libc], [$gt_func_gnugettext_libc], [AC_TRY_LINK([#include $gt_revision_test_code extern int _nl_msg_cat_cntr; extern int *_nl_domain_bindings;], [bindtextdomain ("", ""); return * gettext ("")$gt_expression_test_code + _nl_msg_cat_cntr + *_nl_domain_bindings], [eval "$gt_func_gnugettext_libc=yes"], [eval "$gt_func_gnugettext_libc=no"])]) if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then dnl Sometimes libintl requires libiconv, so first search for libiconv. ifelse(gt_included_intl, yes, , [ AM_ICONV_LINK ]) dnl Search for libintl and define LIBINTL, LTLIBINTL and INCINTL dnl accordingly. Don't use AC_LIB_LINKFLAGS_BODY([intl],[iconv]) dnl because that would add "-liconv" to LIBINTL and LTLIBINTL dnl even if libiconv doesn't exist. AC_LIB_LINKFLAGS_BODY([intl]) AC_CACHE_CHECK([for GNU gettext in libintl], [$gt_func_gnugettext_libintl], [gt_save_CPPFLAGS="$CPPFLAGS" CPPFLAGS="$CPPFLAGS $INCINTL" gt_save_LIBS="$LIBS" LIBS="$LIBS $LIBINTL" dnl Now see whether libintl exists and does not depend on libiconv. AC_TRY_LINK([#include $gt_revision_test_code extern int _nl_msg_cat_cntr; extern #ifdef __cplusplus "C" #endif const char *_nl_expand_alias (const char *);], [bindtextdomain ("", ""); return * gettext ("")$gt_expression_test_code + _nl_msg_cat_cntr + *_nl_expand_alias ("")], [eval "$gt_func_gnugettext_libintl=yes"], [eval "$gt_func_gnugettext_libintl=no"]) dnl Now see whether libintl exists and depends on libiconv. if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" != yes; } && test -n "$LIBICONV"; then LIBS="$LIBS $LIBICONV" AC_TRY_LINK([#include $gt_revision_test_code extern int _nl_msg_cat_cntr; extern #ifdef __cplusplus "C" #endif const char *_nl_expand_alias (const char *);], [bindtextdomain ("", ""); return * gettext ("")$gt_expression_test_code + _nl_msg_cat_cntr + *_nl_expand_alias ("")], [LIBINTL="$LIBINTL $LIBICONV" LTLIBINTL="$LTLIBINTL $LTLIBICONV" eval "$gt_func_gnugettext_libintl=yes" ]) fi CPPFLAGS="$gt_save_CPPFLAGS" LIBS="$gt_save_LIBS"]) fi dnl If an already present or preinstalled GNU gettext() is found, dnl use it. But if this macro is used in GNU gettext, and GNU dnl gettext is already preinstalled in libintl, we update this dnl libintl. (Cf. the install rule in intl/Makefile.in.) if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" = "yes"; } \ || { { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; } \ && test "$PACKAGE" != gettext-runtime \ && test "$PACKAGE" != gettext-tools; }; then gt_use_preinstalled_gnugettext=yes else dnl Reset the values set by searching for libintl. LIBINTL= LTLIBINTL= INCINTL= fi ifelse(gt_included_intl, yes, [ if test "$gt_use_preinstalled_gnugettext" != "yes"; then dnl GNU gettext is not found in the C library. dnl Fall back on included GNU gettext library. nls_cv_use_gnu_gettext=yes fi fi if test "$nls_cv_use_gnu_gettext" = "yes"; then dnl Mark actions used to generate GNU NLS library. BUILD_INCLUDED_LIBINTL=yes USE_INCLUDED_LIBINTL=yes LIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LIBICONV $LIBTHREAD" LTLIBINTL="ifelse([$3],[],\${top_builddir}/intl,[$3])/libintl.[]gt_libtool_suffix_prefix[]a $LTLIBICONV $LTLIBTHREAD" LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'` fi CATOBJEXT= if test "$gt_use_preinstalled_gnugettext" = "yes" \ || test "$nls_cv_use_gnu_gettext" = "yes"; then dnl Mark actions to use GNU gettext tools. CATOBJEXT=.gmo fi ]) if test -n "$INTL_MACOSX_LIBS"; then if test "$gt_use_preinstalled_gnugettext" = "yes" \ || test "$nls_cv_use_gnu_gettext" = "yes"; then dnl Some extra flags are needed during linking. LIBINTL="$LIBINTL $INTL_MACOSX_LIBS" LTLIBINTL="$LTLIBINTL $INTL_MACOSX_LIBS" fi fi if test "$gt_use_preinstalled_gnugettext" = "yes" \ || test "$nls_cv_use_gnu_gettext" = "yes"; then AC_DEFINE([ENABLE_NLS], [1], [Define to 1 if translation of program messages to the user's native language is requested.]) else USE_NLS=no fi fi AC_MSG_CHECKING([whether to use NLS]) AC_MSG_RESULT([$USE_NLS]) if test "$USE_NLS" = "yes"; then AC_MSG_CHECKING([where the gettext function comes from]) if test "$gt_use_preinstalled_gnugettext" = "yes"; then if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then gt_source="external libintl" else gt_source="libc" fi else gt_source="included intl directory" fi AC_MSG_RESULT([$gt_source]) fi if test "$USE_NLS" = "yes"; then if test "$gt_use_preinstalled_gnugettext" = "yes"; then if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then AC_MSG_CHECKING([how to link with libintl]) AC_MSG_RESULT([$LIBINTL]) AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL]) fi dnl For backward compatibility. Some packages may be using this. AC_DEFINE([HAVE_GETTEXT], [1], [Define if the GNU gettext() function is already present or preinstalled.]) AC_DEFINE([HAVE_DCGETTEXT], [1], [Define if the GNU dcgettext() function is already present or preinstalled.]) fi dnl We need to process the po/ directory. POSUB=po fi ifelse(gt_included_intl, yes, [ dnl If this is used in GNU gettext we have to set BUILD_INCLUDED_LIBINTL dnl to 'yes' because some of the testsuite requires it. if test "$PACKAGE" = gettext-runtime || test "$PACKAGE" = gettext-tools; then BUILD_INCLUDED_LIBINTL=yes fi dnl Make all variables we use known to autoconf. AC_SUBST([BUILD_INCLUDED_LIBINTL]) AC_SUBST([USE_INCLUDED_LIBINTL]) AC_SUBST([CATOBJEXT]) dnl For backward compatibility. Some configure.ins may be using this. nls_cv_header_intl= nls_cv_header_libgt= dnl For backward compatibility. Some Makefiles may be using this. DATADIRNAME=share AC_SUBST([DATADIRNAME]) dnl For backward compatibility. Some Makefiles may be using this. INSTOBJEXT=.mo AC_SUBST([INSTOBJEXT]) dnl For backward compatibility. Some Makefiles may be using this. GENCAT=gencat AC_SUBST([GENCAT]) dnl For backward compatibility. Some Makefiles may be using this. INTLOBJS= if test "$USE_INCLUDED_LIBINTL" = yes; then INTLOBJS="\$(GETTOBJS)" fi AC_SUBST([INTLOBJS]) dnl Enable libtool support if the surrounding package wishes it. INTL_LIBTOOL_SUFFIX_PREFIX=gt_libtool_suffix_prefix AC_SUBST([INTL_LIBTOOL_SUFFIX_PREFIX]) ]) dnl For backward compatibility. Some Makefiles may be using this. INTLLIBS="$LIBINTL" AC_SUBST([INTLLIBS]) dnl Make all documented variables known to autoconf. AC_SUBST([LIBINTL]) AC_SUBST([LTLIBINTL]) AC_SUBST([POSUB]) ]) dnl gt_NEEDS_INIT ensures that the gt_needs variable is initialized. m4_define([gt_NEEDS_INIT], [ m4_divert_text([DEFAULTS], [gt_needs=]) m4_define([gt_NEEDS_INIT], []) ]) dnl Usage: AM_GNU_GETTEXT_NEED([NEEDSYMBOL]) AC_DEFUN([AM_GNU_GETTEXT_NEED], [ m4_divert_text([INIT_PREPARE], [gt_needs="$gt_needs $1"]) ]) dnl Usage: AM_GNU_GETTEXT_VERSION([gettext-version]) AC_DEFUN([AM_GNU_GETTEXT_VERSION], []) connman-ui-0_20150622+dfsg.orig/m4/stdint_h.m40000644000175000017500000000164112541725135017155 0ustar nicknick# stdint_h.m4 serial 8 dnl Copyright (C) 1997-2004, 2006, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Paul Eggert. # Define HAVE_STDINT_H_WITH_UINTMAX if exists, # doesn't clash with , and declares uintmax_t. AC_DEFUN([gl_AC_HEADER_STDINT_H], [ AC_CACHE_CHECK([for stdint.h], [gl_cv_header_stdint_h], [AC_TRY_COMPILE( [#include #include ], [uintmax_t i = (uintmax_t) -1; return !i;], [gl_cv_header_stdint_h=yes], [gl_cv_header_stdint_h=no])]) if test $gl_cv_header_stdint_h = yes; then AC_DEFINE_UNQUOTED([HAVE_STDINT_H_WITH_UINTMAX], [1], [Define if exists, doesn't clash with , and declares uintmax_t. ]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/intl.m40000644000175000017500000002705712541725135016320 0ustar nicknick# intl.m4 serial 17 (gettext-0.18) dnl Copyright (C) 1995-2009 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl dnl This file can can be used in projects which are not available under dnl the GNU General Public License or the GNU Library General Public dnl License but which still want to provide support for the GNU gettext dnl functionality. dnl Please note that the actual code of the GNU gettext library is covered dnl by the GNU Library General Public License, and the rest of the GNU dnl gettext package package is covered by the GNU General Public License. dnl They are *not* in the public domain. dnl Authors: dnl Ulrich Drepper , 1995-2000. dnl Bruno Haible , 2000-2009. AC_PREREQ([2.52]) dnl Checks for all prerequisites of the intl subdirectory, dnl except for INTL_LIBTOOL_SUFFIX_PREFIX (and possibly LIBTOOL), INTLOBJS, dnl USE_INCLUDED_LIBINTL, BUILD_INCLUDED_LIBINTL. AC_DEFUN([AM_INTL_SUBDIR], [ AC_REQUIRE([AC_PROG_INSTALL])dnl AC_REQUIRE([AM_PROG_MKDIR_P])dnl defined by automake AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_REQUIRE([gt_GLIBC2])dnl AC_REQUIRE([AC_PROG_RANLIB])dnl AC_REQUIRE([gl_VISIBILITY])dnl AC_REQUIRE([gt_INTL_SUBDIR_CORE])dnl AC_REQUIRE([AC_TYPE_LONG_LONG_INT])dnl AC_REQUIRE([gt_TYPE_WCHAR_T])dnl AC_REQUIRE([gt_TYPE_WINT_T])dnl AC_REQUIRE([gl_AC_HEADER_INTTYPES_H]) AC_REQUIRE([gt_TYPE_INTMAX_T]) AC_REQUIRE([gt_PRINTF_POSIX]) AC_REQUIRE([gl_GLIBC21])dnl AC_REQUIRE([gl_XSIZE])dnl AC_REQUIRE([gl_FCNTL_O_FLAGS])dnl AC_REQUIRE([gt_INTL_MACOSX])dnl dnl Support for automake's --enable-silent-rules. case "$enable_silent_rules" in yes) INTL_DEFAULT_VERBOSITY=0;; no) INTL_DEFAULT_VERBOSITY=1;; *) INTL_DEFAULT_VERBOSITY=1;; esac AC_SUBST([INTL_DEFAULT_VERBOSITY]) AC_CHECK_TYPE([ptrdiff_t], , [AC_DEFINE([ptrdiff_t], [long], [Define as the type of the result of subtracting two pointers, if the system doesn't define it.]) ]) AC_CHECK_HEADERS([stddef.h stdlib.h string.h]) AC_CHECK_FUNCS([asprintf fwprintf newlocale putenv setenv setlocale \ snprintf strnlen wcslen wcsnlen mbrtowc wcrtomb]) dnl Use the _snprintf function only if it is declared (because on NetBSD it dnl is defined as a weak alias of snprintf; we prefer to use the latter). gt_CHECK_DECL(_snprintf, [#include ]) gt_CHECK_DECL(_snwprintf, [#include ]) dnl Use the *_unlocked functions only if they are declared. dnl (because some of them were defined without being declared in Solaris dnl 2.5.1 but were removed in Solaris 2.6, whereas we want binaries built dnl on Solaris 2.5.1 to run on Solaris 2.6). dnl Don't use AC_CHECK_DECLS because it isn't supported in autoconf-2.13. gt_CHECK_DECL(getc_unlocked, [#include ]) case $gt_cv_func_printf_posix in *yes) HAVE_POSIX_PRINTF=1 ;; *) HAVE_POSIX_PRINTF=0 ;; esac AC_SUBST([HAVE_POSIX_PRINTF]) if test "$ac_cv_func_asprintf" = yes; then HAVE_ASPRINTF=1 else HAVE_ASPRINTF=0 fi AC_SUBST([HAVE_ASPRINTF]) if test "$ac_cv_func_snprintf" = yes; then HAVE_SNPRINTF=1 else HAVE_SNPRINTF=0 fi AC_SUBST([HAVE_SNPRINTF]) if test "$ac_cv_func_newlocale" = yes; then HAVE_NEWLOCALE=1 else HAVE_NEWLOCALE=0 fi AC_SUBST([HAVE_NEWLOCALE]) if test "$ac_cv_func_wprintf" = yes; then HAVE_WPRINTF=1 else HAVE_WPRINTF=0 fi AC_SUBST([HAVE_WPRINTF]) AM_LANGINFO_CODESET gt_LC_MESSAGES dnl Compilation on mingw and Cygwin needs special Makefile rules, because dnl 1. when we install a shared library, we must arrange to export dnl auxiliary pointer variables for every exported variable, dnl 2. when we install a shared library and a static library simultaneously, dnl the include file specifies __declspec(dllimport) and therefore we dnl must arrange to define the auxiliary pointer variables for the dnl exported variables _also_ in the static library. if test "$enable_shared" = yes; then case "$host_os" in mingw* | cygwin*) is_woe32dll=yes ;; *) is_woe32dll=no ;; esac else is_woe32dll=no fi WOE32DLL=$is_woe32dll AC_SUBST([WOE32DLL]) dnl On mingw and Cygwin, we can activate special Makefile rules which add dnl version information to the shared libraries and executables. case "$host_os" in mingw* | cygwin*) is_woe32=yes ;; *) is_woe32=no ;; esac WOE32=$is_woe32 AC_SUBST([WOE32]) if test $WOE32 = yes; then dnl Check for a program that compiles Windows resource files. AC_CHECK_TOOL([WINDRES], [windres]) fi dnl Determine whether when creating a library, "-lc" should be passed to dnl libtool or not. On many platforms, it is required for the libtool option dnl -no-undefined to work. On HP-UX, however, the -lc - stored by libtool dnl in the *.la files - makes it impossible to create multithreaded programs, dnl because libtool also reorders the -lc to come before the -pthread, and dnl this disables pthread_create() . case "$host_os" in hpux*) LTLIBC="" ;; *) LTLIBC="-lc" ;; esac AC_SUBST([LTLIBC]) dnl Rename some macros and functions used for locking. AH_BOTTOM([ #define __libc_lock_t gl_lock_t #define __libc_lock_define gl_lock_define #define __libc_lock_define_initialized gl_lock_define_initialized #define __libc_lock_init gl_lock_init #define __libc_lock_lock gl_lock_lock #define __libc_lock_unlock gl_lock_unlock #define __libc_lock_recursive_t gl_recursive_lock_t #define __libc_lock_define_recursive gl_recursive_lock_define #define __libc_lock_define_initialized_recursive gl_recursive_lock_define_initialized #define __libc_lock_init_recursive gl_recursive_lock_init #define __libc_lock_lock_recursive gl_recursive_lock_lock #define __libc_lock_unlock_recursive gl_recursive_lock_unlock #define glthread_in_use libintl_thread_in_use #define glthread_lock_init_func libintl_lock_init_func #define glthread_lock_lock_func libintl_lock_lock_func #define glthread_lock_unlock_func libintl_lock_unlock_func #define glthread_lock_destroy_func libintl_lock_destroy_func #define glthread_rwlock_init_multithreaded libintl_rwlock_init_multithreaded #define glthread_rwlock_init_func libintl_rwlock_init_func #define glthread_rwlock_rdlock_multithreaded libintl_rwlock_rdlock_multithreaded #define glthread_rwlock_rdlock_func libintl_rwlock_rdlock_func #define glthread_rwlock_wrlock_multithreaded libintl_rwlock_wrlock_multithreaded #define glthread_rwlock_wrlock_func libintl_rwlock_wrlock_func #define glthread_rwlock_unlock_multithreaded libintl_rwlock_unlock_multithreaded #define glthread_rwlock_unlock_func libintl_rwlock_unlock_func #define glthread_rwlock_destroy_multithreaded libintl_rwlock_destroy_multithreaded #define glthread_rwlock_destroy_func libintl_rwlock_destroy_func #define glthread_recursive_lock_init_multithreaded libintl_recursive_lock_init_multithreaded #define glthread_recursive_lock_init_func libintl_recursive_lock_init_func #define glthread_recursive_lock_lock_multithreaded libintl_recursive_lock_lock_multithreaded #define glthread_recursive_lock_lock_func libintl_recursive_lock_lock_func #define glthread_recursive_lock_unlock_multithreaded libintl_recursive_lock_unlock_multithreaded #define glthread_recursive_lock_unlock_func libintl_recursive_lock_unlock_func #define glthread_recursive_lock_destroy_multithreaded libintl_recursive_lock_destroy_multithreaded #define glthread_recursive_lock_destroy_func libintl_recursive_lock_destroy_func #define glthread_once_func libintl_once_func #define glthread_once_singlethreaded libintl_once_singlethreaded #define glthread_once_multithreaded libintl_once_multithreaded ]) ]) dnl Checks for the core files of the intl subdirectory: dnl dcigettext.c dnl eval-plural.h dnl explodename.c dnl finddomain.c dnl gettextP.h dnl gmo.h dnl hash-string.h hash-string.c dnl l10nflist.c dnl libgnuintl.h.in (except the *printf stuff) dnl loadinfo.h dnl loadmsgcat.c dnl localealias.c dnl log.c dnl plural-exp.h plural-exp.c dnl plural.y dnl Used by libglocale. AC_DEFUN([gt_INTL_SUBDIR_CORE], [ AC_REQUIRE([AC_C_INLINE])dnl AC_REQUIRE([AC_TYPE_SIZE_T])dnl AC_REQUIRE([gl_AC_HEADER_STDINT_H]) AC_REQUIRE([AC_FUNC_ALLOCA])dnl AC_REQUIRE([AC_FUNC_MMAP])dnl AC_REQUIRE([gt_INTDIV0])dnl AC_REQUIRE([gl_AC_TYPE_UINTMAX_T])dnl AC_REQUIRE([gt_INTTYPES_PRI])dnl AC_REQUIRE([gl_LOCK])dnl AC_TRY_LINK( [int foo (int a) { a = __builtin_expect (a, 10); return a == 10 ? 0 : 1; }], [], [AC_DEFINE([HAVE_BUILTIN_EXPECT], [1], [Define to 1 if the compiler understands __builtin_expect.])]) AC_CHECK_HEADERS([argz.h inttypes.h limits.h unistd.h sys/param.h]) AC_CHECK_FUNCS([getcwd getegid geteuid getgid getuid mempcpy munmap \ stpcpy strcasecmp strdup strtoul tsearch uselocale argz_count \ argz_stringify argz_next __fsetlocking]) dnl Use the *_unlocked functions only if they are declared. dnl (because some of them were defined without being declared in Solaris dnl 2.5.1 but were removed in Solaris 2.6, whereas we want binaries built dnl on Solaris 2.5.1 to run on Solaris 2.6). dnl Don't use AC_CHECK_DECLS because it isn't supported in autoconf-2.13. gt_CHECK_DECL([feof_unlocked], [#include ]) gt_CHECK_DECL([fgets_unlocked], [#include ]) AM_ICONV dnl intl/plural.c is generated from intl/plural.y. It requires bison, dnl because plural.y uses bison specific features. It requires at least dnl bison-1.26 because earlier versions generate a plural.c that doesn't dnl compile. dnl bison is only needed for the maintainer (who touches plural.y). But in dnl order to avoid separate Makefiles or --enable-maintainer-mode, we put dnl the rule in general Makefile. Now, some people carelessly touch the dnl files or have a broken "make" program, hence the plural.c rule will dnl sometimes fire. To avoid an error, defines BISON to ":" if it is not dnl present or too old. AC_CHECK_PROGS([INTLBISON], [bison]) if test -z "$INTLBISON"; then ac_verc_fail=yes else dnl Found it, now check the version. AC_MSG_CHECKING([version of bison]) changequote(<<,>>)dnl ac_prog_version=`$INTLBISON --version 2>&1 | sed -n 's/^.*GNU Bison.* \([0-9]*\.[0-9.]*\).*$/\1/p'` case $ac_prog_version in '') ac_prog_version="v. ?.??, bad"; ac_verc_fail=yes;; 1.2[6-9]* | 1.[3-9][0-9]* | [2-9].*) changequote([,])dnl ac_prog_version="$ac_prog_version, ok"; ac_verc_fail=no;; *) ac_prog_version="$ac_prog_version, bad"; ac_verc_fail=yes;; esac AC_MSG_RESULT([$ac_prog_version]) fi if test $ac_verc_fail = yes; then INTLBISON=: fi ]) dnl gt_CHECK_DECL(FUNC, INCLUDES) dnl Check whether a function is declared. AC_DEFUN([gt_CHECK_DECL], [ AC_CACHE_CHECK([whether $1 is declared], [ac_cv_have_decl_$1], [AC_TRY_COMPILE([$2], [ #ifndef $1 char *p = (char *) $1; #endif ], ac_cv_have_decl_$1=yes, ac_cv_have_decl_$1=no)]) if test $ac_cv_have_decl_$1 = yes; then gt_value=1 else gt_value=0 fi AC_DEFINE_UNQUOTED([HAVE_DECL_]translit($1, [a-z], [A-Z]), [$gt_value], [Define to 1 if you have the declaration of `$1', and to 0 if you don't.]) ]) connman-ui-0_20150622+dfsg.orig/m4/lib-prefix.m40000644000175000017500000002042212541725135017400 0ustar nicknick# lib-prefix.m4 serial 7 (gettext-0.18) dnl Copyright (C) 2001-2005, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't dnl require excessive bracketing. ifdef([AC_HELP_STRING], [AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])], [AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])]) dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed dnl to access previously installed libraries. The basic assumption is that dnl a user will want packages to use other packages he previously installed dnl with the same --prefix option. dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate dnl libraries, but is otherwise very convenient. AC_DEFUN([AC_LIB_PREFIX], [ AC_BEFORE([$0], [AC_LIB_LINKFLAGS]) AC_REQUIRE([AC_PROG_CC]) AC_REQUIRE([AC_CANONICAL_HOST]) AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) dnl By default, look in $includedir and $libdir. use_additional=yes AC_LIB_WITH_FINAL_PREFIX([ eval additional_includedir=\"$includedir\" eval additional_libdir=\"$libdir\" ]) AC_LIB_ARG_WITH([lib-prefix], [ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib --without-lib-prefix don't search for libraries in includedir and libdir], [ if test "X$withval" = "Xno"; then use_additional=no else if test "X$withval" = "X"; then AC_LIB_WITH_FINAL_PREFIX([ eval additional_includedir=\"$includedir\" eval additional_libdir=\"$libdir\" ]) else additional_includedir="$withval/include" additional_libdir="$withval/$acl_libdirstem" fi fi ]) if test $use_additional = yes; then dnl Potentially add $additional_includedir to $CPPFLAGS. dnl But don't add it dnl 1. if it's the standard /usr/include, dnl 2. if it's already present in $CPPFLAGS, dnl 3. if it's /usr/local/include and we are using GCC on Linux, dnl 4. if it doesn't exist as a directory. if test "X$additional_includedir" != "X/usr/include"; then haveit= for x in $CPPFLAGS; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-I$additional_includedir"; then haveit=yes break fi done if test -z "$haveit"; then if test "X$additional_includedir" = "X/usr/local/include"; then if test -n "$GCC"; then case $host_os in linux* | gnu* | k*bsd*-gnu) haveit=yes;; esac fi fi if test -z "$haveit"; then if test -d "$additional_includedir"; then dnl Really add $additional_includedir to $CPPFLAGS. CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir" fi fi fi fi dnl Potentially add $additional_libdir to $LDFLAGS. dnl But don't add it dnl 1. if it's the standard /usr/lib, dnl 2. if it's already present in $LDFLAGS, dnl 3. if it's /usr/local/lib and we are using GCC on Linux, dnl 4. if it doesn't exist as a directory. if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then haveit= for x in $LDFLAGS; do AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) if test "X$x" = "X-L$additional_libdir"; then haveit=yes break fi done if test -z "$haveit"; then if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then if test -n "$GCC"; then case $host_os in linux*) haveit=yes;; esac fi fi if test -z "$haveit"; then if test -d "$additional_libdir"; then dnl Really add $additional_libdir to $LDFLAGS. LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir" fi fi fi fi fi ]) dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix, dnl acl_final_exec_prefix, containing the values to which $prefix and dnl $exec_prefix will expand at the end of the configure script. AC_DEFUN([AC_LIB_PREPARE_PREFIX], [ dnl Unfortunately, prefix and exec_prefix get only finally determined dnl at the end of configure. if test "X$prefix" = "XNONE"; then acl_final_prefix="$ac_default_prefix" else acl_final_prefix="$prefix" fi if test "X$exec_prefix" = "XNONE"; then acl_final_exec_prefix='${prefix}' else acl_final_exec_prefix="$exec_prefix" fi acl_save_prefix="$prefix" prefix="$acl_final_prefix" eval acl_final_exec_prefix=\"$acl_final_exec_prefix\" prefix="$acl_save_prefix" ]) dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the dnl variables prefix and exec_prefix bound to the values they will have dnl at the end of the configure script. AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX], [ acl_save_prefix="$prefix" prefix="$acl_final_prefix" acl_save_exec_prefix="$exec_prefix" exec_prefix="$acl_final_exec_prefix" $1 exec_prefix="$acl_save_exec_prefix" prefix="$acl_save_prefix" ]) dnl AC_LIB_PREPARE_MULTILIB creates dnl - a variable acl_libdirstem, containing the basename of the libdir, either dnl "lib" or "lib64" or "lib/64", dnl - a variable acl_libdirstem2, as a secondary possible value for dnl acl_libdirstem, either the same as acl_libdirstem or "lib/sparcv9" or dnl "lib/amd64". AC_DEFUN([AC_LIB_PREPARE_MULTILIB], [ dnl There is no formal standard regarding lib and lib64. dnl On glibc systems, the current practice is that on a system supporting dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. We determine dnl the compiler's default mode by looking at the compiler's library search dnl path. If at least one of its elements ends in /lib64 or points to a dnl directory whose absolute pathname ends in /lib64, we assume a 64-bit ABI. dnl Otherwise we use the default, namely "lib". dnl On Solaris systems, the current practice is that on a system supporting dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib. AC_REQUIRE([AC_CANONICAL_HOST]) acl_libdirstem=lib acl_libdirstem2= case "$host_os" in solaris*) dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment dnl . dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link." dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the dnl symlink is missing, so we set acl_libdirstem2 too. AC_CACHE_CHECK([for 64-bit host], [gl_cv_solaris_64bit], [AC_EGREP_CPP([sixtyfour bits], [ #ifdef _LP64 sixtyfour bits #endif ], [gl_cv_solaris_64bit=yes], [gl_cv_solaris_64bit=no]) ]) if test $gl_cv_solaris_64bit = yes; then acl_libdirstem=lib/64 case "$host_cpu" in sparc*) acl_libdirstem2=lib/sparcv9 ;; i*86 | x86_64) acl_libdirstem2=lib/amd64 ;; esac fi ;; *) searchpath=`(LC_ALL=C $CC -print-search-dirs) 2>/dev/null | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'` if test -n "$searchpath"; then acl_save_IFS="${IFS= }"; IFS=":" for searchdir in $searchpath; do if test -d "$searchdir"; then case "$searchdir" in */lib64/ | */lib64 ) acl_libdirstem=lib64 ;; */../ | */.. ) # Better ignore directories of this form. They are misleading. ;; *) searchdir=`cd "$searchdir" && pwd` case "$searchdir" in */lib64 ) acl_libdirstem=lib64 ;; esac ;; esac fi done IFS="$acl_save_IFS" fi ;; esac test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem" ]) connman-ui-0_20150622+dfsg.orig/m4/progtest.m40000644000175000017500000000557312541725135017220 0ustar nicknick# progtest.m4 serial 6 (gettext-0.18) dnl Copyright (C) 1996-2003, 2005, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl dnl This file can can be used in projects which are not available under dnl the GNU General Public License or the GNU Library General Public dnl License but which still want to provide support for the GNU gettext dnl functionality. dnl Please note that the actual code of the GNU gettext library is covered dnl by the GNU Library General Public License, and the rest of the GNU dnl gettext package package is covered by the GNU General Public License. dnl They are *not* in the public domain. dnl Authors: dnl Ulrich Drepper , 1996. AC_PREREQ([2.50]) # Search path for a program which passes the given test. dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR, dnl TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]]) AC_DEFUN([AM_PATH_PROG_WITH_TEST], [ # Prepare PATH_SEPARATOR. # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then echo "#! /bin/sh" >conf$$.sh echo "exit 0" >>conf$$.sh chmod +x conf$$.sh if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=';' else PATH_SEPARATOR=: fi rm -f conf$$.sh fi # Find out how to test for executable files. Don't use a zero-byte file, # as systems may use methods other than mode bits to determine executability. cat >conf$$.file <<_ASEOF #! /bin/sh exit 0 _ASEOF chmod +x conf$$.file if test -x conf$$.file >/dev/null 2>&1; then ac_executable_p="test -x" else ac_executable_p="test -f" fi rm -f conf$$.file # Extract the first word of "$2", so it can be a program name with args. set dummy $2; ac_word=[$]2 AC_MSG_CHECKING([for $ac_word]) AC_CACHE_VAL([ac_cv_path_$1], [case "[$]$1" in [[\\/]]* | ?:[[\\/]]*) ac_cv_path_$1="[$]$1" # Let the user override the test with a path. ;; *) ac_save_IFS="$IFS"; IFS=$PATH_SEPARATOR for ac_dir in ifelse([$5], , $PATH, [$5]); do IFS="$ac_save_IFS" test -z "$ac_dir" && ac_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if $ac_executable_p "$ac_dir/$ac_word$ac_exec_ext"; then echo "$as_me: trying $ac_dir/$ac_word..." >&AS_MESSAGE_LOG_FD if [$3]; then ac_cv_path_$1="$ac_dir/$ac_word$ac_exec_ext" break 2 fi fi done done IFS="$ac_save_IFS" dnl If no 4th arg is given, leave the cache variable unset, dnl so AC_PATH_PROGS will keep looking. ifelse([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4" ])dnl ;; esac])dnl $1="$ac_cv_path_$1" if test ifelse([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then AC_MSG_RESULT([$][$1]) else AC_MSG_RESULT([no]) fi AC_SUBST([$1])dnl ]) connman-ui-0_20150622+dfsg.orig/m4/intmax.m40000644000175000017500000000204012541725135016633 0ustar nicknick# intmax.m4 serial 5 (gettext-0.18) dnl Copyright (C) 2002-2005, 2008-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. dnl Test whether the system has the 'intmax_t' type, but don't attempt to dnl find a replacement if it is lacking. AC_DEFUN([gt_TYPE_INTMAX_T], [ AC_REQUIRE([gl_AC_HEADER_INTTYPES_H]) AC_REQUIRE([gl_AC_HEADER_STDINT_H]) AC_CACHE_CHECK([for intmax_t], [gt_cv_c_intmax_t], [AC_TRY_COMPILE([ #include #include #if HAVE_STDINT_H_WITH_UINTMAX #include #endif #if HAVE_INTTYPES_H_WITH_UINTMAX #include #endif ], [intmax_t x = -1; return !x;], [gt_cv_c_intmax_t=yes], [gt_cv_c_intmax_t=no])]) if test $gt_cv_c_intmax_t = yes; then AC_DEFINE([HAVE_INTMAX_T], [1], [Define if you have the 'intmax_t' type in or .]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/printf-posix.m40000644000175000017500000000275112541725135020006 0ustar nicknick# printf-posix.m4 serial 5 (gettext-0.18) dnl Copyright (C) 2003, 2007, 2009-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. dnl Test whether the printf() function supports POSIX/XSI format strings with dnl positions. AC_DEFUN([gt_PRINTF_POSIX], [ AC_REQUIRE([AC_PROG_CC]) AC_CACHE_CHECK([whether printf() supports POSIX/XSI format strings], gt_cv_func_printf_posix, [ AC_TRY_RUN([ #include #include /* The string "%2$d %1$d", with dollar characters protected from the shell's dollar expansion (possibly an autoconf bug). */ static char format[] = { '%', '2', '$', 'd', ' ', '%', '1', '$', 'd', '\0' }; static char buf[100]; int main () { sprintf (buf, format, 33, 55); return (strcmp (buf, "55 33") != 0); }], gt_cv_func_printf_posix=yes, gt_cv_func_printf_posix=no, [ AC_EGREP_CPP([notposix], [ #if defined __NetBSD__ || defined __BEOS__ || defined _MSC_VER || defined __MINGW32__ || defined __CYGWIN__ notposix #endif ], [gt_cv_func_printf_posix="guessing no"], [gt_cv_func_printf_posix="guessing yes"]) ]) ]) case $gt_cv_func_printf_posix in *yes) AC_DEFINE([HAVE_POSIX_PRINTF], [1], [Define if your printf() function supports format strings with positions.]) ;; esac ]) connman-ui-0_20150622+dfsg.orig/m4/ltversion.m40000644000175000017500000000126212541725135017365 0ustar nicknick# ltversion.m4 -- version numbers -*- Autoconf -*- # # Copyright (C) 2004 Free Software Foundation, Inc. # Written by Scott James Remnant, 2004 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # @configure_input@ # serial 3337 ltversion.m4 # This file is part of GNU Libtool m4_define([LT_PACKAGE_VERSION], [2.4.2]) m4_define([LT_PACKAGE_REVISION], [1.3337]) AC_DEFUN([LTVERSION_VERSION], [macro_version='2.4.2' macro_revision='1.3337' _LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) _LT_DECL(, macro_revision, 0) ]) connman-ui-0_20150622+dfsg.orig/m4/iconv.m40000644000175000017500000001653712541725135016471 0ustar nicknick# iconv.m4 serial 11 (gettext-0.18.1) dnl Copyright (C) 2000-2002, 2007-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. AC_DEFUN([AM_ICONV_LINKFLAGS_BODY], [ dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) AC_REQUIRE([AC_LIB_RPATH]) dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV dnl accordingly. AC_LIB_LINKFLAGS_BODY([iconv]) ]) AC_DEFUN([AM_ICONV_LINK], [ dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and dnl those with the standalone portable GNU libiconv installed). AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV dnl accordingly. AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) dnl Add $INCICONV to CPPFLAGS before performing the following checks, dnl because if the user has installed libiconv and not disabled its use dnl via --without-libiconv-prefix, he wants to use it. The first dnl AC_TRY_LINK will then fail, the second AC_TRY_LINK will succeed. am_save_CPPFLAGS="$CPPFLAGS" AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV]) AC_CACHE_CHECK([for iconv], [am_cv_func_iconv], [ am_cv_func_iconv="no, consider installing GNU libiconv" am_cv_lib_iconv=no AC_TRY_LINK([#include #include ], [iconv_t cd = iconv_open("",""); iconv(cd,NULL,NULL,NULL,NULL); iconv_close(cd);], [am_cv_func_iconv=yes]) if test "$am_cv_func_iconv" != yes; then am_save_LIBS="$LIBS" LIBS="$LIBS $LIBICONV" AC_TRY_LINK([#include #include ], [iconv_t cd = iconv_open("",""); iconv(cd,NULL,NULL,NULL,NULL); iconv_close(cd);], [am_cv_lib_iconv=yes] [am_cv_func_iconv=yes]) LIBS="$am_save_LIBS" fi ]) if test "$am_cv_func_iconv" = yes; then AC_CACHE_CHECK([for working iconv], [am_cv_func_iconv_works], [ dnl This tests against bugs in AIX 5.1, HP-UX 11.11, Solaris 10. am_save_LIBS="$LIBS" if test $am_cv_lib_iconv = yes; then LIBS="$LIBS $LIBICONV" fi AC_TRY_RUN([ #include #include int main () { /* Test against AIX 5.1 bug: Failures are not distinguishable from successful returns. */ { iconv_t cd_utf8_to_88591 = iconv_open ("ISO8859-1", "UTF-8"); if (cd_utf8_to_88591 != (iconv_t)(-1)) { static const char input[] = "\342\202\254"; /* EURO SIGN */ char buf[10]; const char *inptr = input; size_t inbytesleft = strlen (input); char *outptr = buf; size_t outbytesleft = sizeof (buf); size_t res = iconv (cd_utf8_to_88591, (char **) &inptr, &inbytesleft, &outptr, &outbytesleft); if (res == 0) return 1; } } /* Test against Solaris 10 bug: Failures are not distinguishable from successful returns. */ { iconv_t cd_ascii_to_88591 = iconv_open ("ISO8859-1", "646"); if (cd_ascii_to_88591 != (iconv_t)(-1)) { static const char input[] = "\263"; char buf[10]; const char *inptr = input; size_t inbytesleft = strlen (input); char *outptr = buf; size_t outbytesleft = sizeof (buf); size_t res = iconv (cd_ascii_to_88591, (char **) &inptr, &inbytesleft, &outptr, &outbytesleft); if (res == 0) return 1; } } #if 0 /* This bug could be worked around by the caller. */ /* Test against HP-UX 11.11 bug: Positive return value instead of 0. */ { iconv_t cd_88591_to_utf8 = iconv_open ("utf8", "iso88591"); if (cd_88591_to_utf8 != (iconv_t)(-1)) { static const char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337"; char buf[50]; const char *inptr = input; size_t inbytesleft = strlen (input); char *outptr = buf; size_t outbytesleft = sizeof (buf); size_t res = iconv (cd_88591_to_utf8, (char **) &inptr, &inbytesleft, &outptr, &outbytesleft); if ((int)res > 0) return 1; } } #endif /* Test against HP-UX 11.11 bug: No converter from EUC-JP to UTF-8 is provided. */ if (/* Try standardized names. */ iconv_open ("UTF-8", "EUC-JP") == (iconv_t)(-1) /* Try IRIX, OSF/1 names. */ && iconv_open ("UTF-8", "eucJP") == (iconv_t)(-1) /* Try AIX names. */ && iconv_open ("UTF-8", "IBM-eucJP") == (iconv_t)(-1) /* Try HP-UX names. */ && iconv_open ("utf8", "eucJP") == (iconv_t)(-1)) return 1; return 0; }], [am_cv_func_iconv_works=yes], [am_cv_func_iconv_works=no], [case "$host_os" in aix* | hpux*) am_cv_func_iconv_works="guessing no" ;; *) am_cv_func_iconv_works="guessing yes" ;; esac]) LIBS="$am_save_LIBS" ]) case "$am_cv_func_iconv_works" in *no) am_func_iconv=no am_cv_lib_iconv=no ;; *) am_func_iconv=yes ;; esac else am_func_iconv=no am_cv_lib_iconv=no fi if test "$am_func_iconv" = yes; then AC_DEFINE([HAVE_ICONV], [1], [Define if you have the iconv() function and it works.]) fi if test "$am_cv_lib_iconv" = yes; then AC_MSG_CHECKING([how to link with libiconv]) AC_MSG_RESULT([$LIBICONV]) else dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV dnl either. CPPFLAGS="$am_save_CPPFLAGS" LIBICONV= LTLIBICONV= fi AC_SUBST([LIBICONV]) AC_SUBST([LTLIBICONV]) ]) dnl Define AM_ICONV using AC_DEFUN_ONCE for Autoconf >= 2.64, in order to dnl avoid warnings like dnl "warning: AC_REQUIRE: `AM_ICONV' was expanded before it was required". dnl This is tricky because of the way 'aclocal' is implemented: dnl - It requires defining an auxiliary macro whose name ends in AC_DEFUN. dnl Otherwise aclocal's initial scan pass would miss the macro definition. dnl - It requires a line break inside the AC_DEFUN_ONCE and AC_DEFUN expansions. dnl Otherwise aclocal would emit many "Use of uninitialized value $1" dnl warnings. m4_define([gl_iconv_AC_DEFUN], m4_version_prereq([2.64], [[AC_DEFUN_ONCE( [$1], [$2])]], [[AC_DEFUN( [$1], [$2])]])) gl_iconv_AC_DEFUN([AM_ICONV], [ AM_ICONV_LINK if test "$am_cv_func_iconv" = yes; then AC_MSG_CHECKING([for iconv declaration]) AC_CACHE_VAL([am_cv_proto_iconv], [ AC_TRY_COMPILE([ #include #include extern #ifdef __cplusplus "C" #endif #if defined(__STDC__) || defined(__cplusplus) size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft); #else size_t iconv(); #endif ], [], [am_cv_proto_iconv_arg1=""], [am_cv_proto_iconv_arg1="const"]) am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"]) am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'` AC_MSG_RESULT([ $am_cv_proto_iconv]) AC_DEFINE_UNQUOTED([ICONV_CONST], [$am_cv_proto_iconv_arg1], [Define as const if the declaration of iconv() needs const.]) fi ]) connman-ui-0_20150622+dfsg.orig/m4/lib-ld.m40000644000175000017500000000660312541725135016507 0ustar nicknick# lib-ld.m4 serial 4 (gettext-0.18) dnl Copyright (C) 1996-2003, 2009-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl Subroutines of libtool.m4, dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision dnl with libtool.m4. dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no. AC_DEFUN([AC_LIB_PROG_LD_GNU], [AC_CACHE_CHECK([if the linker ($LD) is GNU ld], [acl_cv_prog_gnu_ld], [# I'd rather use --version here, but apparently some GNU ld's only accept -v. case `$LD -v 2>&1 conf$$.sh echo "exit 0" >>conf$$.sh chmod +x conf$$.sh if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then PATH_SEPARATOR=';' else PATH_SEPARATOR=: fi rm -f conf$$.sh fi ac_prog=ld if test "$GCC" = yes; then # Check if gcc -print-prog-name=ld gives a path. AC_MSG_CHECKING([for ld used by GCC]) case $host in *-*-mingw*) # gcc leaves a trailing carriage return which upsets mingw ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; *) ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; esac case $ac_prog in # Accept absolute paths. [[\\/]* | [A-Za-z]:[\\/]*)] [re_direlt='/[^/][^/]*/\.\./'] # Canonicalize the path of ld ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'` while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"` done test -z "$LD" && LD="$ac_prog" ;; "") # If it fails, then pretend we aren't using GCC. ac_prog=ld ;; *) # If it is relative, then search for the first ld in PATH. with_gnu_ld=unknown ;; esac elif test "$with_gnu_ld" = yes; then AC_MSG_CHECKING([for GNU ld]) else AC_MSG_CHECKING([for non-GNU ld]) fi AC_CACHE_VAL([acl_cv_path_LD], [if test -z "$LD"; then IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" for ac_dir in $PATH; do test -z "$ac_dir" && ac_dir=. if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then acl_cv_path_LD="$ac_dir/$ac_prog" # Check to see if the program is GNU ld. I'd rather use --version, # but apparently some GNU ld's only accept -v. # Break only if it was the GNU/non-GNU ld that we prefer. case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in *GNU* | *'with BFD'*) test "$with_gnu_ld" != no && break ;; *) test "$with_gnu_ld" != yes && break ;; esac fi done IFS="$ac_save_ifs" else acl_cv_path_LD="$LD" # Let the user override the test with a path. fi]) LD="$acl_cv_path_LD" if test -n "$LD"; then AC_MSG_RESULT([$LD]) else AC_MSG_RESULT([no]) fi test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH]) AC_LIB_PROG_LD_GNU ]) connman-ui-0_20150622+dfsg.orig/m4/lt~obsolete.m40000644000175000017500000001375612541725135017725 0ustar nicknick# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- # # Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc. # Written by Scott James Remnant, 2004. # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # serial 5 lt~obsolete.m4 # These exist entirely to fool aclocal when bootstrapping libtool. # # In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN) # which have later been changed to m4_define as they aren't part of the # exported API, or moved to Autoconf or Automake where they belong. # # The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN # in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us # using a macro with the same name in our local m4/libtool.m4 it'll # pull the old libtool.m4 in (it doesn't see our shiny new m4_define # and doesn't know about Autoconf macros at all.) # # So we provide this file, which has a silly filename so it's always # included after everything else. This provides aclocal with the # AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything # because those macros already exist, or will be overwritten later. # We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. # # Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. # Yes, that means every name once taken will need to remain here until # we give up compatibility with versions before 1.7, at which point # we need to keep only those names which we still refer to. # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])]) m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])]) m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])]) m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])]) m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])]) m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])]) m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])]) m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])]) m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])]) m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])]) m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])]) m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])]) m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])]) m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])]) m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])]) m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])]) m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])]) m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])]) m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])]) m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])]) m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])]) m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])]) m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])]) m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])]) m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])]) m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])]) m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])]) m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])]) m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])]) m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])]) m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])]) m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])]) m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])]) m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])]) m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])]) m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])]) m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])]) m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])]) m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])]) m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])]) m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])]) m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])]) m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])]) m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])]) m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])]) m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])]) m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])]) m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])]) m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])]) m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])]) m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])]) m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])]) m4_ifndef([_LT_AC_PROG_CXXCPP], [AC_DEFUN([_LT_AC_PROG_CXXCPP])]) m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])]) m4_ifndef([_LT_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])]) m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_LT_PROG_F77])]) m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])]) m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])]) connman-ui-0_20150622+dfsg.orig/m4/ltsugar.m40000644000175000017500000001042412541725135017021 0ustar nicknick# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- # # Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. # Written by Gary V. Vaughan, 2004 # # This file is free software; the Free Software Foundation gives # unlimited permission to copy and/or distribute it, with or without # modifications, as long as this notice is preserved. # serial 6 ltsugar.m4 # This is to help aclocal find these macros, as it can't see m4_define. AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) # lt_join(SEP, ARG1, [ARG2...]) # ----------------------------- # Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their # associated separator. # Needed until we can rely on m4_join from Autoconf 2.62, since all earlier # versions in m4sugar had bugs. m4_define([lt_join], [m4_if([$#], [1], [], [$#], [2], [[$2]], [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])]) m4_define([_lt_join], [m4_if([$#$2], [2], [], [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])]) # lt_car(LIST) # lt_cdr(LIST) # ------------ # Manipulate m4 lists. # These macros are necessary as long as will still need to support # Autoconf-2.59 which quotes differently. m4_define([lt_car], [[$1]]) m4_define([lt_cdr], [m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], [$#], 1, [], [m4_dquote(m4_shift($@))])]) m4_define([lt_unquote], $1) # lt_append(MACRO-NAME, STRING, [SEPARATOR]) # ------------------------------------------ # Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'. # Note that neither SEPARATOR nor STRING are expanded; they are appended # to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). # No SEPARATOR is output if MACRO-NAME was previously undefined (different # than defined and empty). # # This macro is needed until we can rely on Autoconf 2.62, since earlier # versions of m4sugar mistakenly expanded SEPARATOR but not STRING. m4_define([lt_append], [m4_define([$1], m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])]) # lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...]) # ---------------------------------------------------------- # Produce a SEP delimited list of all paired combinations of elements of # PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list # has the form PREFIXmINFIXSUFFIXn. # Needed until we can rely on m4_combine added in Autoconf 2.62. m4_define([lt_combine], [m4_if(m4_eval([$# > 3]), [1], [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl [[m4_foreach([_Lt_prefix], [$2], [m4_foreach([_Lt_suffix], ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[, [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])]) # lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ]) # ----------------------------------------------------------------------- # Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited # by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ. m4_define([lt_if_append_uniq], [m4_ifdef([$1], [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1], [lt_append([$1], [$2], [$3])$4], [$5])], [lt_append([$1], [$2], [$3])$4])]) # lt_dict_add(DICT, KEY, VALUE) # ----------------------------- m4_define([lt_dict_add], [m4_define([$1($2)], [$3])]) # lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE) # -------------------------------------------- m4_define([lt_dict_add_subkey], [m4_define([$1($2:$3)], [$4])]) # lt_dict_fetch(DICT, KEY, [SUBKEY]) # ---------------------------------- m4_define([lt_dict_fetch], [m4_ifval([$3], m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]), m4_ifdef([$1($2)], [m4_defn([$1($2)])]))]) # lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE]) # ----------------------------------------------------------------- m4_define([lt_if_dict_fetch], [m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4], [$5], [$6])]) # lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...]) # -------------------------------------------------------------- m4_define([lt_dict_filter], [m4_if([$5], [], [], [lt_join(m4_quote(m4_default([$4], [[, ]])), lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]), [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl ]) connman-ui-0_20150622+dfsg.orig/m4/intdiv0.m40000644000175000017500000000444612541725135016724 0ustar nicknick# intdiv0.m4 serial 3 (gettext-0.18) dnl Copyright (C) 2002, 2007-2010 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, dnl with or without modifications, as long as this notice is preserved. dnl From Bruno Haible. AC_DEFUN([gt_INTDIV0], [ AC_REQUIRE([AC_PROG_CC])dnl AC_REQUIRE([AC_CANONICAL_HOST])dnl AC_CACHE_CHECK([whether integer division by zero raises SIGFPE], gt_cv_int_divbyzero_sigfpe, [ gt_cv_int_divbyzero_sigfpe= changequote(,)dnl case "$host_os" in macos* | darwin[6-9]* | darwin[1-9][0-9]*) # On MacOS X 10.2 or newer, just assume the same as when cross- # compiling. If we were to perform the real test, 1 Crash Report # dialog window would pop up. case "$host_cpu" in i[34567]86 | x86_64) gt_cv_int_divbyzero_sigfpe="guessing yes" ;; esac ;; esac changequote([,])dnl if test -z "$gt_cv_int_divbyzero_sigfpe"; then AC_TRY_RUN([ #include #include static void sigfpe_handler (int sig) { /* Exit with code 0 if SIGFPE, with code 1 if any other signal. */ exit (sig != SIGFPE); } int x = 1; int y = 0; int z; int nan; int main () { signal (SIGFPE, sigfpe_handler); /* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP. */ #if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP) signal (SIGTRAP, sigfpe_handler); #endif /* Linux/SPARC yields signal SIGILL. */ #if defined (__sparc__) && defined (__linux__) signal (SIGILL, sigfpe_handler); #endif z = x / y; nan = y / y; exit (1); } ], [gt_cv_int_divbyzero_sigfpe=yes], [gt_cv_int_divbyzero_sigfpe=no], [ # Guess based on the CPU. changequote(,)dnl case "$host_cpu" in alpha* | i[34567]86 | x86_64 | m68k | s390*) gt_cv_int_divbyzero_sigfpe="guessing yes";; *) gt_cv_int_divbyzero_sigfpe="guessing no";; esac changequote([,])dnl ]) fi ]) case "$gt_cv_int_divbyzero_sigfpe" in *yes) value=1;; *) value=0;; esac AC_DEFINE_UNQUOTED([INTDIV0_RAISES_SIGFPE], [$value], [Define if integer division by zero raises signal SIGFPE.]) ]) connman-ui-0_20150622+dfsg.orig/bootstrap-configure0000755000175000017500000000011112541725135020470 0ustar nicknick#!/bin/sh set -e ./autogen.sh ./configure --enable-maintainer-mode "$@"