pidgin/pidgin

Use Meson summary() function.

2021-07-27, Elliott Sales de Andrade
cb640ea0f315
Use Meson summary() function.

Now that we require at least 0.52, we can use Meson's builtin summary printing to display the results of configuration.

Testing Done:
Configured with defaults, and with pixmaps disabled to trigger the warning: https://asciinema.org/a/mV2oxOoVCJNdmrPwgqqUJ3mkU?t=17

Reviewed at https://reviews.imfreedom.org/r/848/
/*
* nmcontact.c
*
* Copyright (c) 2004 Novell, Inc. 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 as published by
* the Free Software Foundation; version 2 of the License.
*
* 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 Street, Fifth Floor, Boston, MA 02111-1301 USA
*
*/
#include <glib.h>
#include <string.h>
#include <purple.h>
#include "nmcontact.h"
#include "nmfield.h"
#include "nmuser.h"
struct _NMContact
{
int id;
int parent_id;
int seq;
char *dn;
char *display_name;
NMUserRecord *user_record;
gpointer data;
int ref_count;
};
struct _NMFolder
{
int id;
int seq;
char *name;
GSList *folders;
GSList *contacts;
int ref_count;
};
static int count = 0;
static void _release_folder_contacts(NMFolder * folder);
static void _release_folder_folders(NMFolder * folder);
static void _add_contacts(NMUser * user, NMFolder * folder, NMField * fields);
static void _add_folders(NMFolder * root, NMField * fields);
/*********************************************************************
* Contact API
*********************************************************************/
NMContact *
nm_create_contact()
{
NMContact *contact = g_new0(NMContact, 1);
contact->ref_count = 1;
purple_debug_info("novell", "Creating contact, total=%d", count++);
return contact;
}
/*
* This creates a contact for the contact list. The
* field array that is passed in should be a
* NM_A_FA_CONTACT array.
*
*/
NMContact *
nm_create_contact_from_fields(NMField * fields)
{
NMContact *contact;
NMField *field;
if ( fields == NULL || fields->tag == NULL || fields->ptr_value == 0 ||
!purple_strequal(fields->tag, NM_A_FA_CONTACT) )
{
return NULL;
}
contact = nm_create_contact();
if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
contact->id = atoi((char *) field->ptr_value);
}
if ((field = nm_locate_field(NM_A_SZ_PARENT_ID, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
contact->parent_id = atoi((char *) field->ptr_value);
}
if ((field =
nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
contact->seq = atoi((char *) field->ptr_value);
}
if ((field =
nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
contact->display_name = g_strdup((char *) field->ptr_value);
}
if ((field = nm_locate_field(NM_A_SZ_DN, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
contact->dn = g_strdup((char *) field->ptr_value);
}
return contact;
}
void
nm_contact_update_list_properties(NMContact * contact, NMField * fields)
{
NMField *field;
if (contact == NULL || fields == NULL || fields->ptr_value == 0)
return;
if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
contact->id = atoi((char *)field->ptr_value);
}
if ((field = nm_locate_field(NM_A_SZ_PARENT_ID, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
contact->parent_id = atoi((char *) field->ptr_value);
}
if ((field =
nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
contact->seq = atoi((char *) field->ptr_value);
}
if ((field =
nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->ptr_value))) {
if (field->ptr_value) {
g_free(contact->display_name);
contact->display_name = g_strdup((char *) field->ptr_value);
}
}
if ((field = nm_locate_field(NM_A_SZ_DN, (NMField *) fields->ptr_value))) {
if (field->ptr_value) {
g_free(contact->dn);
contact->dn = g_strdup((char *) field->ptr_value);
}
}
}
NMField *
nm_contact_to_fields(NMContact * contact)
{
NMField *fields = NULL;
if (contact == NULL)
return NULL;
fields = nm_field_add_pointer(fields, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
g_strdup_printf("%d", contact->id), NMFIELD_TYPE_UTF8);
fields = nm_field_add_pointer(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
g_strdup_printf("%d", contact->parent_id), NMFIELD_TYPE_UTF8);
fields = nm_field_add_pointer(fields, NM_A_SZ_SEQUENCE_NUMBER, 0, NMFIELD_METHOD_VALID, 0,
g_strdup_printf("%d", contact->seq), NMFIELD_TYPE_UTF8);
if (contact->display_name != NULL) {
fields = nm_field_add_pointer(fields, NM_A_SZ_DISPLAY_NAME, 0, NMFIELD_METHOD_VALID, 0,
g_strdup(contact->display_name), NMFIELD_TYPE_UTF8);
}
if (contact->dn != NULL) {
fields = nm_field_add_pointer(fields, NM_A_SZ_DN, 0, NMFIELD_METHOD_VALID, 0,
g_strdup(contact->dn), NMFIELD_TYPE_UTF8);
}
return fields;
}
void
nm_contact_add_ref(NMContact * contact)
{
if (contact)
contact->ref_count++;
}
void
nm_release_contact(NMContact * contact)
{
if (contact == NULL)
return;
if (--(contact->ref_count) == 0) {
purple_debug_info("novell", "Releasing contact, total=%d", --count);
g_free(contact->display_name);
g_free(contact->dn);
if (contact->user_record) {
nm_release_user_record(contact->user_record);
}
g_free(contact);
}
}
const char *
nm_contact_get_display_name(NMContact * contact)
{
if (contact == NULL)
return NULL;
if (contact->user_record != NULL && contact->display_name == NULL) {
const char *full_name, *lname, *fname, *cn, *display_id;
full_name = nm_user_record_get_full_name(contact->user_record);
fname = nm_user_record_get_first_name(contact->user_record);
lname = nm_user_record_get_last_name(contact->user_record);
cn = nm_user_record_get_userid(contact->user_record);
display_id = nm_user_record_get_display_id(contact->user_record);
/* Try to build a display name. */
if (full_name) {
contact->display_name = g_strdup(full_name);
} else if (fname && lname) {
contact->display_name = g_strdup_printf("%s %s", fname, lname);
} else {
/* If auth attribute is set use it */
if (nm_user_record_get_auth_attr(contact->user_record) &&
display_id != NULL) {
contact->display_name = g_strdup(display_id);
} else {
/* Use CN or display id */
if (cn) {
contact->display_name = g_strdup(cn);
} else if (display_id) {
contact->display_name = g_strdup(display_id);
}
}
}
}
return contact->display_name;
}
void
nm_contact_set_display_name(NMContact * contact, const char *display_name)
{
if (contact == NULL)
return;
g_free(contact->display_name);
contact->display_name = NULL;
if (display_name)
contact->display_name = g_strdup(display_name);
}
void
nm_contact_set_dn(NMContact * contact, const char *dn)
{
if (contact == NULL)
return;
g_free(contact->dn);
contact->dn = NULL;
if (dn)
contact->dn = g_strdup(dn);
}
const char *
nm_contact_get_dn(NMContact * contact)
{
if (contact == NULL)
return NULL;
return contact->dn;
}
gpointer
nm_contact_get_data(NMContact * contact)
{
if (contact == NULL)
return NULL;
return contact->data;
}
int
nm_contact_get_id(NMContact * contact)
{
if (contact == NULL)
return -1;
return contact->id;
}
int
nm_contact_get_parent_id(NMContact * contact)
{
if (contact == NULL)
return -1;
return contact->parent_id;
}
void
nm_contact_set_data(NMContact * contact, gpointer data)
{
if (contact == NULL)
return;
contact->data = data;
}
void
nm_contact_set_user_record(NMContact * contact, NMUserRecord * user_record)
{
if (contact == NULL)
return;
if (contact->user_record) {
nm_release_user_record(contact->user_record);
}
nm_user_record_add_ref(user_record);
contact->user_record = user_record;
}
NMUserRecord *
nm_contact_get_user_record(NMContact * contact)
{
if (contact == NULL)
return NULL;
return contact->user_record;
}
const char *
nm_contact_get_userid(NMContact * contact)
{
NMUserRecord *user_record;
const char *userid = NULL;
if (contact == NULL)
return NULL;
user_record = nm_contact_get_user_record(contact);
if (user_record) {
userid = nm_user_record_get_userid(user_record);
}
return userid;
}
const char *
nm_contact_get_display_id(NMContact * contact)
{
NMUserRecord *user_record;
const char *id = NULL;
if (contact == NULL)
return NULL;
user_record = nm_contact_get_user_record(contact);
if (user_record) {
id = nm_user_record_get_display_id(user_record);
}
return id;
}
/*********************************************************************
* Folder API
*********************************************************************/
NMFolder *
nm_create_folder(const char *name)
{
NMFolder *folder = g_new0(NMFolder, 1);
if (name)
folder->name = g_strdup(name);
folder->ref_count = 1;
return folder;
}
NMFolder *
nm_create_folder_from_fields(NMField * fields)
{
NMField *field;
NMFolder *folder;
if (fields == NULL || fields->ptr_value == 0)
return NULL;
folder = g_new0(NMFolder, 1);
if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
folder->id = atoi((char *) field->ptr_value);
}
if ((field =
nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
folder->seq = atoi((char *) field->ptr_value);
}
if ((field =
nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
folder->name = g_strdup((char *) field->ptr_value);
}
folder->ref_count = 1;
return folder;
}
NMField *
nm_folder_to_fields(NMFolder * folder)
{
NMField *fields = NULL;
if (folder == NULL)
return NULL;
fields = nm_field_add_pointer(fields, NM_A_SZ_OBJECT_ID, 0, NMFIELD_METHOD_VALID, 0,
g_strdup_printf("%d", folder->id), NMFIELD_TYPE_UTF8);
fields = nm_field_add_pointer(fields, NM_A_SZ_PARENT_ID, 0, NMFIELD_METHOD_VALID, 0,
g_strdup("0"), NMFIELD_TYPE_UTF8);
fields = nm_field_add_pointer(fields, NM_A_SZ_TYPE, 0, NMFIELD_METHOD_VALID, 0,
g_strdup("1"), NMFIELD_TYPE_UTF8);
fields = nm_field_add_pointer(fields, NM_A_SZ_SEQUENCE_NUMBER, 0, NMFIELD_METHOD_VALID, 0,
g_strdup_printf("%d", folder->seq), NMFIELD_TYPE_UTF8);
if (folder->name != NULL) {
fields = nm_field_add_pointer(fields, NM_A_SZ_DISPLAY_NAME, 0, NMFIELD_METHOD_VALID, 0,
g_strdup(folder->name), NMFIELD_TYPE_UTF8);
}
return fields;
}
void
nm_folder_update_list_properties(NMFolder * folder, NMField * fields)
{
NMField *field;
if (folder == NULL || fields == NULL || fields->ptr_value == 0)
return;
if ((field = nm_locate_field(NM_A_SZ_OBJECT_ID, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
folder->id = atoi((char *) field->ptr_value);
}
if ((field =
nm_locate_field(NM_A_SZ_SEQUENCE_NUMBER, (NMField *) fields->ptr_value))) {
if (field->ptr_value)
folder->seq = atoi((char *) field->ptr_value);
}
if ((field =
nm_locate_field(NM_A_SZ_DISPLAY_NAME, (NMField *) fields->ptr_value))) {
if (field->ptr_value) {
g_free(folder->name);
folder->name = g_strdup((char *) field->ptr_value);
}
}
}
void
nm_release_folder(NMFolder * folder)
{
if (folder == NULL)
return;
if (--(folder->ref_count) == 0) {
g_free(folder->name);
if (folder->folders) {
_release_folder_folders(folder);
}
if (folder->contacts) {
_release_folder_contacts(folder);
}
g_free(folder);
}
}
void
nm_folder_add_ref(NMFolder * folder)
{
if (folder)
folder->ref_count++;
}
int
nm_folder_get_subfolder_count(NMFolder * folder)
{
if (folder == NULL)
return 0;
if (folder->folders)
return g_slist_length(folder->folders);
else
return 0;
}
NMFolder *
nm_folder_get_subfolder(NMFolder * folder, int index)
{
if (folder == NULL)
return NULL;
if (folder->folders)
return (NMFolder *) g_slist_nth_data(folder->folders, index);
else
return NULL;
}
int
nm_folder_get_contact_count(NMFolder * folder)
{
if (folder == NULL)
return 0;
if (folder->contacts != NULL)
return g_slist_length(folder->contacts);
else
return 0;
}
NMContact *
nm_folder_get_contact(NMFolder * folder, int index)
{
if (folder == NULL)
return NULL;
if (folder->contacts)
return (NMContact *) g_slist_nth_data(folder->contacts, index);
else
return NULL;
}
const char *
nm_folder_get_name(NMFolder * folder)
{
if (folder == NULL)
return NULL;
return folder->name;
}
void
nm_folder_set_name(NMFolder * folder, const char *name)
{
if (folder == NULL || name == NULL)
return;
g_free(folder->name);
folder->name = g_strdup(name);
}
int
nm_folder_get_id(NMFolder * folder)
{
if (folder == NULL) {
return -1;
}
return folder->id;
}
void
nm_folder_add_folder_to_list(NMFolder * root, NMFolder * folder)
{
GSList *node;
if (root == NULL || folder == NULL)
return;
node = root->folders;
while (node) {
if (folder->seq <= ((NMFolder *) node->data)->seq) {
nm_folder_add_ref(folder);
root->folders = g_slist_insert_before(root->folders, node, folder);
break;
}
node = g_slist_next(node);
}
if (node == NULL) {
nm_folder_add_ref(folder);
root->folders = g_slist_append(root->folders, folder);
}
}
void
nm_folder_remove_contact(NMFolder * folder, NMContact * contact)
{
GSList *node;
if (folder == NULL || contact == NULL)
return;
node = folder->contacts;
while (node) {
if (contact->id == ((NMContact *) (node->data))->id) {
folder->contacts = g_slist_delete_link(folder->contacts, node);
nm_release_contact(contact);
break;
}
node = g_slist_next(node);
}
}
void
nm_folder_add_contact_to_list(NMFolder * root_folder, NMContact * contact)
{
GSList *node = NULL;
NMFolder *folder = root_folder;
if (folder == NULL || contact == NULL)
return;
/* Find folder to add contact to */
if (contact->parent_id != 0) {
node = folder->folders;
while (node) {
folder = (NMFolder *) node->data;
if (contact->parent_id == folder->id) {
break;
}
folder = NULL;
node = g_slist_next(node);
}
}
/* Add contact to list */
if (folder) {
node = folder->contacts;
while (node) {
if (contact->seq <= ((NMContact *) (node->data))->seq) {
nm_contact_add_ref(contact);
folder->contacts =
g_slist_insert_before(folder->contacts, node, contact);
break;
}
node = g_slist_next(node);
}
if (node == NULL) {
nm_contact_add_ref(contact);
folder->contacts = g_slist_append(folder->contacts, contact);
}
}
}
void
nm_folder_add_contacts_and_folders(NMUser * user, NMFolder * root,
NMField * fields)
{
/* Add the contacts and folders from the field array */
if (user && root && fields) {
_add_folders(root, fields);
_add_contacts(user, root, fields);
}
}
gpointer
nm_folder_find_item_by_object_id(NMFolder * root_folder, int object_id)
{
int cnt, cnt2, i, j;
gpointer item = NULL;
NMFolder *folder;
NMContact *contact;
if (root_folder == NULL)
return NULL;
/* Check all contacts for the top level folder */
cnt = nm_folder_get_contact_count(root_folder);
for (i = 0; i < cnt; i++) {
contact = nm_folder_get_contact(root_folder, i);
if (contact && (contact->id == object_id)) {
item = contact;
break;
}
}
/* If we haven't found the item yet, check the subfolders */
if (item == NULL) {
cnt = nm_folder_get_subfolder_count(root_folder);
for (i = 0; (i < cnt) && (item == NULL); i++) {
folder = nm_folder_get_subfolder(root_folder, i);
/* Check the id of this folder */
if (folder && (folder->id == object_id)) {
item = folder;
break;
}
/* Check all contacts for this folder */
cnt2 = nm_folder_get_contact_count(folder);
for (j = 0; j < cnt2; j++) {
contact = nm_folder_get_contact(folder, j);
if (contact && (contact->id == object_id)) {
item = contact;
break;
}
}
}
}
return item;
}
NMContact *
nm_folder_find_contact_by_userid(NMFolder * folder, const char *userid)
{
int cnt, i;
NMContact *tmp, *contact = NULL;
if (folder == NULL || userid == NULL)
return NULL;
cnt = nm_folder_get_contact_count(folder);
for (i = 0; i < cnt; i++) {
tmp = nm_folder_get_contact(folder, i);
if (tmp && nm_utf8_str_equal(nm_contact_get_userid(tmp), userid)) {
contact = tmp;
break;
}
}
return contact;
}
NMContact *
nm_folder_find_contact_by_display_id(NMFolder * folder, const char *display_id)
{
int cnt, i;
NMContact *tmp, *contact = NULL;
if (folder == NULL || display_id == NULL)
return NULL;
cnt = nm_folder_get_contact_count(folder);
for (i = 0; i < cnt; i++) {
tmp = nm_folder_get_contact(folder, i);
if (tmp && nm_utf8_str_equal(nm_contact_get_display_id(tmp), display_id)) {
contact = tmp;
break;
}
}
return contact;
}
NMContact *
nm_folder_find_contact(NMFolder * folder, const char *dn)
{
int cnt, i;
NMContact *tmp, *contact = NULL;
if (folder == NULL || dn == NULL)
return NULL;
cnt = nm_folder_get_contact_count(folder);
for (i = 0; i < cnt; i++) {
tmp = nm_folder_get_contact(folder, i);
if (tmp && nm_utf8_str_equal(nm_contact_get_dn(tmp), dn)) {
contact = tmp;
break;
}
}
return contact;
}
/*********************************************************************
* Utility functions
*********************************************************************/
static void
_release_folder_contacts(NMFolder * folder)
{
g_slist_free_full(folder->contacts, (GDestroyNotify)nm_release_contact);
folder->contacts = NULL;
}
static void
_release_folder_folders(NMFolder * folder)
{
if (folder == NULL)
return;
g_slist_free_full(folder->folders, (GDestroyNotify)nm_release_folder);
folder->folders = NULL;
}
static void
_add_folders(NMFolder * root, NMField * fields)
{
NMFolder *folder = NULL;
NMField *locate = NULL;
locate = nm_locate_field(NM_A_FA_FOLDER, fields);
while (locate != NULL) {
/* Create a new folder */
folder = nm_create_folder_from_fields(locate);
/* Add subfolder to roots folder list */
nm_folder_add_folder_to_list(root, folder);
/* Decrement the ref count */
nm_release_folder(folder);
/* Find the next folder */
locate = nm_locate_field(NM_A_FA_FOLDER, locate+1);
}
}
static void
_add_contacts(NMUser * user, NMFolder * folder, NMField * fields)
{
NMContact *contact = NULL;
NMField *locate = NULL, *details;
NMUserRecord *user_record = NULL;
locate = nm_locate_field(NM_A_FA_CONTACT, fields);
while (locate != NULL) {
/* Create a new contact from the fields */
contact = nm_create_contact_from_fields(locate);
/* Add it to our contact list */
nm_folder_add_contact_to_list(folder, contact);
/* Update the contact cache */
nm_user_add_contact(user, contact);
/* Update the user record cache */
if ((details = nm_locate_field(NM_A_FA_USER_DETAILS,
(NMField *) locate->ptr_value))) {
user_record = nm_find_user_record(user, nm_contact_get_dn(contact));
if (user_record == NULL) {
user_record = nm_create_user_record_from_fields(details);
nm_user_record_set_dn(user_record, nm_contact_get_dn(contact));
nm_user_add_user_record(user, user_record);
nm_release_user_record(user_record);
}
nm_contact_set_user_record(contact, user_record);
}
nm_release_contact(contact);
locate = nm_locate_field(NM_A_FA_CONTACT, locate+1);
}
}