1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/*
* sssd_dbus_messages_helpers.c
*
* Created on: Jul 9, 2011
* Author: r00tkit
*/
#include <sys/time.h>
#include <errno.h>
#include "util/util.h"
#include "dbus/dbus.h"
#include "sbus/sssd_dbus.h"
#include "sbus/sssd_dbus_private.h"
#include <dhash.h>
#include "sbus/sssd_dbus_messages_helpers.h"
void callback_delete(hash_entry_t *entry, hash_destroy_enum type, void *pvt)
{
if (entry->value.type == HASH_VALUE_PTR)
free(entry->value.ptr);
}
int dbus_dhash_to_msg_iter(hash_table_t **table_in,
DBusMessageIter *msg_iter_start)
{
hash_table_t * local_table = NULL;
hash_entry_t *entry;
struct hash_iter_context_t *iter;
char * str_value,*str_key;
DBusMessageIter *msg_iter;
DBusMessageIter sub_iter;
DBusMessageIter dict_iter;
msg_iter = msg_iter_start;
if( !table_in && !*table_in) {
fprintf(stderr,"Table is not valid.");
return SSS_SBUS_DHASH_NULL;
}
local_table = *table_in;
if(!dbus_message_iter_open_container(msg_iter,
DBUS_TYPE_ARRAY,
"{ss}",
&sub_iter)) {
fprintf(stderr, "Out Of Memory!\n");
return SSS_SBUS_ITER_MESSAGE_ERR;
}
iter = new_hash_iter_context(local_table);
while ((entry = iter->next(iter)) != NULL) {
if(entry->key.type != HASH_KEY_STRING && entry->value.type != HASH_VALUE_PTR) {
fprintf(stderr,"fatal: Unexpected hashtable");
return SSS_SBUS_DHASH_INVALID;
}
str_key = strdup((char *) entry->key.str);
str_value = strdup((char *) entry->value.ptr);
if(!dbus_message_iter_open_container(&sub_iter,
DBUS_TYPE_DICT_ENTRY,
NULL,
&dict_iter)) {
fprintf(stderr, "Out Of Memory!\n");
return SSS_SBUS_ITER_MESSAGE_ERR;
}
if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &str_key)) {
fprintf(stderr, "Out Of Memory!\n");
return SSS_SBUS_ITER_MESSAGE_ERR;
}
if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &str_value)) {
fprintf(stderr, "Out Of Memory!\n");
return SSS_SBUS_ITER_MESSAGE_ERR;
}
free(str_key);
free(str_value);
if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
fprintf(stderr, "Out Of Memory!\n");
return SSS_SBUS_ITER_MESSAGE_ERR;
}
}
free(iter);
if (!dbus_message_iter_close_container(msg_iter,&sub_iter)) {
fprintf(stderr, "Out Of Memory!\n");
return SSS_SBUS_ITER_MESSAGE_ERR;
}
return SSS_SBUS_CONV_SUCCESS;
}
int dbus_msg_iter_to_dhash(DBusMessageIter *iter, hash_table_t **table_out)
{
DBusMessageIter msg_iter;
DBusMessageIter sub_iter;
DBusMessageIter dict_iter;
hash_table_t *local_table = NULL;
hash_key_t key;
hash_value_t value;
int err_h;
char * tmp;
msg_iter = *iter;
err_h = hash_create((unsigned long)INIT_TABLE_SIZE,
&local_table,
callback_delete,
NULL);
if (err_h != HASH_SUCCESS) {
fprintf(stderr, "couldn't create hash table (%s)\n", hash_error_string(err_h));
return err_h;
}
if(DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&msg_iter)) {
fprintf(stderr,"message Iter is invalid\n");
return SSS_SBUS_ITER_INVALID_ERR;
}
else {
dbus_message_iter_recurse(&msg_iter, &sub_iter);
}
while(1){
if(DBUS_TYPE_DICT_ENTRY != dbus_message_iter_get_arg_type(&sub_iter)) {
fprintf(stderr,"dict content failed");
}
else {
dbus_message_iter_recurse(&sub_iter, &dict_iter);
}
if(DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&dict_iter)) {
printf("string array content failed");
return SSS_SBUS_ITER_MESSAGE_ERR;
}
else {
key.type = HASH_KEY_STRING;
value.type = HASH_VALUE_PTR;
dbus_message_iter_get_basic(&dict_iter, &tmp);
key.str = tmp;
fprintf(stdout,"%s : ",key.str);
dbus_message_iter_next (&dict_iter);
if(DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&dict_iter)) {
printf("string array content failed");
return SSS_SBUS_ITER_MESSAGE_ERR;
}
dbus_message_iter_get_basic(&dict_iter, &tmp);
value.ptr = tmp;
fprintf(stdout,"%s\n",(char *)value.ptr);
if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
fprintf(stderr, "couldn't add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
return err_h;
}
if(!dbus_message_iter_next (&sub_iter)) {
/* struct ended. */
break;
}
}
}
*table_out = local_table;
return SSS_SBUS_CONV_SUCCESS;
}
|
