pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
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/
/*
* nmfield.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
<string.h>
#include
<stdio.h>
#include
"nmfield.h"
/* Free a field value and tag */
static
void
_free_field
(
NMField
*
field
);
/* Free a field value */
static
void
_free_field_value
(
NMField
*
field
);
/* Make a deep copy of the field */
static
void
_copy_field
(
NMField
*
dest
,
NMField
*
src
);
/* Make a deep copy of the field's value */
static
void
_copy_field_value
(
NMField
*
dest
,
NMField
*
src
);
/* Create a string from a value -- for debugging */
static
char
*
_value_to_string
(
NMField
*
field
);
static
NMField
*
_add_blank_field
(
NMField
*
fields
,
guint32
count
)
{
guint32
new_len
;
if
(
fields
==
NULL
)
{
fields
=
g_new0
(
NMField
,
10
);
fields
->
len
=
10
;
}
else
{
if
(
fields
->
len
<
count
+
2
)
{
new_len
=
count
+
10
;
fields
=
g_realloc
(
fields
,
new_len
*
sizeof
(
NMField
));
fields
->
len
=
new_len
;
}
}
return
fields
;
}
NMField
*
nm_field_add_number
(
NMField
*
fields
,
const
char
*
tag
,
guint32
size
,
guint8
method
,
guint8
flags
,
guint32
value
,
guint8
type
)
{
guint32
count
;
NMField
*
field
;
count
=
nm_count_fields
(
fields
);
fields
=
_add_blank_field
(
fields
,
count
);
field
=
&
(
fields
[
count
]);
field
->
tag
=
g_strdup
(
tag
);
field
->
size
=
size
;
field
->
method
=
method
;
field
->
flags
=
flags
;
field
->
value
=
value
;
field
->
type
=
type
;
/* Null terminate the field array */
field
=
&
((
fields
)[
count
+
1
]);
field
->
tag
=
NULL
;
field
->
value
=
0
;
field
->
ptr_value
=
NULL
;
return
fields
;
}
NMField
*
nm_field_add_pointer
(
NMField
*
fields
,
const
char
*
tag
,
guint32
size
,
guint8
method
,
guint8
flags
,
gpointer
value
,
guint8
type
)
{
guint32
count
;
NMField
*
field
=
NULL
;
count
=
nm_count_fields
(
fields
);
fields
=
_add_blank_field
(
fields
,
count
);
field
=
&
(
fields
[
count
]);
field
->
tag
=
g_strdup
(
tag
);
field
->
size
=
size
;
field
->
method
=
method
;
field
->
flags
=
flags
;
field
->
ptr_value
=
value
;
field
->
type
=
type
;
/* Null terminate the field array */
field
=
&
((
fields
)[
count
+
1
]);
field
->
tag
=
NULL
;
field
->
value
=
0
;
field
->
ptr_value
=
NULL
;
return
fields
;
}
guint32
nm_count_fields
(
NMField
*
fields
)
{
guint32
count
=
0
;
if
(
fields
)
{
while
(
fields
->
tag
!=
NULL
)
{
count
++
;
fields
++
;
}
}
return
count
;
}
void
nm_free_fields
(
NMField
**
fields
)
{
NMField
*
field
=
NULL
;
if
((
fields
==
NULL
)
||
(
*
fields
==
NULL
))
return
;
field
=
*
fields
;
while
(
field
->
tag
!=
NULL
)
{
_free_field
(
field
);
field
++
;
}
g_free
(
*
fields
);
*
fields
=
NULL
;
}
static
void
_free_field
(
NMField
*
field
)
{
if
(
field
==
NULL
)
return
;
_free_field_value
(
field
);
g_free
(
field
->
tag
);
}
static
void
_free_field_value
(
NMField
*
field
)
{
if
(
field
==
NULL
)
return
;
switch
(
field
->
type
)
{
case
NMFIELD_TYPE_BINARY
:
case
NMFIELD_TYPE_UTF8
:
case
NMFIELD_TYPE_DN
:
g_free
(
field
->
ptr_value
);
break
;
case
NMFIELD_TYPE_ARRAY
:
case
NMFIELD_TYPE_MV
:
nm_free_fields
((
NMField
**
)
&
field
->
ptr_value
);
break
;
default
:
break
;
}
field
->
size
=
0
;
field
->
ptr_value
=
NULL
;
}
NMField
*
nm_locate_field
(
char
*
tag
,
NMField
*
fields
)
{
NMField
*
ret_fields
=
NULL
;
if
((
fields
==
NULL
)
||
(
tag
==
NULL
))
{
return
NULL
;
}
while
(
fields
->
tag
!=
NULL
)
{
if
(
g_ascii_strcasecmp
(
fields
->
tag
,
tag
)
==
0
)
{
ret_fields
=
fields
;
break
;
}
fields
++
;
}
return
ret_fields
;
}
NMField
*
nm_copy_field_array
(
NMField
*
src
)
{
NMField
*
ptr
=
NULL
;
NMField
*
dest
=
NULL
;
int
count
;
if
(
src
!=
NULL
)
{
count
=
nm_count_fields
(
src
)
+
1
;
dest
=
g_new0
(
NMField
,
count
);
dest
->
len
=
count
;
ptr
=
dest
;
while
(
src
->
tag
!=
NULL
)
{
_copy_field
(
ptr
,
src
);
ptr
++
;
src
++
;
}
}
return
dest
;
}
static
void
_copy_field
(
NMField
*
dest
,
NMField
*
src
)
{
dest
->
type
=
src
->
type
;
dest
->
flags
=
src
->
flags
;
dest
->
method
=
src
->
method
;
dest
->
tag
=
g_strdup
(
src
->
tag
);
_copy_field_value
(
dest
,
src
);
}
static
void
_copy_field_value
(
NMField
*
dest
,
NMField
*
src
)
{
dest
->
type
=
src
->
type
;
switch
(
dest
->
type
)
{
case
NMFIELD_TYPE_UTF8
:
case
NMFIELD_TYPE_DN
:
if
(
src
->
size
==
0
&&
src
->
ptr_value
!=
NULL
)
{
src
->
size
=
strlen
((
char
*
)
src
->
ptr_value
)
+
1
;
}
/* fall through */
case
NMFIELD_TYPE_BINARY
:
if
(
src
->
size
!=
0
&&
src
->
ptr_value
!=
NULL
)
{
dest
->
ptr_value
=
g_new0
(
char
,
src
->
size
);
memcpy
(
dest
->
ptr_value
,
src
->
ptr_value
,
src
->
size
);
}
break
;
case
NMFIELD_TYPE_ARRAY
:
case
NMFIELD_TYPE_MV
:
dest
->
ptr_value
=
nm_copy_field_array
((
NMField
*
)
src
->
ptr_value
);
break
;
default
:
/* numeric value */
dest
->
value
=
src
->
value
;
break
;
}
dest
->
size
=
src
->
size
;
}
void
nm_remove_field
(
NMField
*
field
)
{
NMField
*
tmp
;
guint32
len
;
if
((
field
!=
NULL
)
&&
(
field
->
tag
!=
NULL
))
{
_free_field
(
field
);
/* Move fields down */
tmp
=
field
+
1
;
while
(
1
)
{
/* Don't overwrite the size of the array */
len
=
field
->
len
;
*
field
=
*
tmp
;
field
->
len
=
len
;
if
(
tmp
->
tag
==
NULL
)
break
;
field
++
;
tmp
++
;
}
}
}
void
nm_print_fields
(
NMField
*
fields
)
{
char
*
str
=
NULL
;
NMField
*
field
=
fields
;
if
(
fields
==
NULL
)
return
;
while
(
field
->
tag
!=
NULL
)
{
if
(
field
->
type
==
NMFIELD_TYPE_ARRAY
||
field
->
type
==
NMFIELD_TYPE_MV
)
{
printf
(
"Subarray START: %s Method = %d
\n
"
,
field
->
tag
,
field
->
method
);
nm_print_fields
((
NMField
*
)
field
->
ptr_value
);
printf
(
"Subarray END: %s
\n
"
,
field
->
tag
);
}
else
{
str
=
_value_to_string
(
field
);
printf
(
"Tag=%s;Value=%s
\n
"
,
field
->
tag
,
str
);
g_free
(
str
);
str
=
NULL
;
}
field
++
;
}
}
static
char
*
_value_to_string
(
NMField
*
field
)
{
char
*
value
=
NULL
;
if
(
field
==
NULL
)
return
NULL
;
/* This is a single value attribute */
if
(((
field
->
type
==
NMFIELD_TYPE_UTF8
)
||
(
field
->
type
==
NMFIELD_TYPE_DN
))
&&
(
field
->
ptr_value
!=
NULL
))
{
value
=
g_strdup
((
const
char
*
)
field
->
ptr_value
);
}
else
if
(
field
->
type
==
NMFIELD_TYPE_BINARY
&&
field
->
ptr_value
!=
NULL
)
{
value
=
g_new0
(
char
,
field
->
size
);
memcpy
(
value
,
(
const
char
*
)
field
->
ptr_value
,
field
->
size
);
}
else
if
(
field
->
type
==
NMFIELD_TYPE_BOOL
)
{
if
(
field
->
value
)
{
value
=
g_strdup
(
NM_FIELD_TRUE
);
}
else
{
value
=
g_strdup
(
NM_FIELD_FALSE
);
}
}
else
{
/* assume it is a number */
switch
(
field
->
type
)
{
case
NMFIELD_TYPE_BYTE
:
case
NMFIELD_TYPE_WORD
:
case
NMFIELD_TYPE_DWORD
:
value
=
g_strdup_printf
(
"%ld"
,
(
long
)
field
->
value
);
break
;
case
NMFIELD_TYPE_UBYTE
:
case
NMFIELD_TYPE_UWORD
:
case
NMFIELD_TYPE_UDWORD
:
value
=
g_strdup_printf
(
"%lu"
,
(
unsigned
long
)
field
->
value
);
break
;
}
}
if
(
value
==
NULL
)
value
=
g_strdup
(
"NULL"
);
return
value
;
}