← Back to branch summary

~ubuntu-branches/ubuntu/maverick/evolution-data-server/maverick-proposed

« back to all changes in this revision

Viewing changes to servers/exchange/lib/e2k-sid.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-05-17 17:02:06 UTC
  • mfrom: (1.1.79 upstream) (1.6.12 experimental)
  • Revision ID: james.westby@ubuntu.com-20100517170206-4ufr52vwrhh26yh0
Tags: 2.30.1-1ubuntu1
https://launchpad.net/bugs/42199
https://launchpad.net/bugs/229669
https://launchpad.net/bugs/173703
https://launchpad.net/bugs/360344
https://launchpad.net/bugs/508494
* Merge from debian experimental. Remaining change:
  (LP: #42199, #229669, #173703, #360344, #508494)
  + debian/control:
    - add Vcs-Bzr tag
    - don't use libgnome
    - Use Breaks instead of Conflicts against evolution 2.25 and earlier.
  + debian/evolution-data-server.install,
    debian/patches/45_libcamel_providers_version.patch:
    - use the upstream versioning, not a Debian-specific one 
  + debian/libedata-book1.2-dev.install, debian/libebackend-1.2-dev.install,
    debian/libcamel1.2-dev.install, debian/libedataserverui1.2-dev.install:
    - install html documentation
  + debian/rules:
    - don't build documentation it's shipped with the tarball

Show diffs side-by-side

added added

removed removed

Lines of Context:
servers/exchange/lib/e2k-sid.c
1
 
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2
 
 
3
 
/* Copyright (C) 2002-2004 Novell, Inc.
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or
6
 
 * modify it under the terms of version 2 of the GNU Lesser General Public
7
 
 * License as published by the Free Software Foundation.
8
 
 *
9
 
 * This program is distributed in the hope that it will be useful,
10
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 
 * General Public License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU Lesser General Public
15
 
 * License along with this program; if not, write to the
16
 
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17
 
 * Boston, MA 02110-1301, USA.
18
 
 */
19
 
 
20
 
#ifdef HAVE_CONFIG_H
21
 
#include "config.h"
22
 
#endif
23
 
 
24
 
#include "e2k-sid.h"
25
 
 
26
 
#include <stdlib.h>
27
 
#include <string.h>
28
 
#include <glib.h>
29
 
#include <libxml/xmlmemory.h>
30
 
 
31
 
typedef struct {
32
 
        guint8  Revision;
33
 
        guint8  SubAuthorityCount;
34
 
        guint8  zero_pad[5];
35
 
        guint8  IdentifierAuthority;
36
 
        guint32 SubAuthority[1];
37
 
} E2kSid_SID;
38
 
#define E2K_SID_SID_REVISION 1
39
 
 
40
 
struct _E2kSidPrivate {
41
 
        E2kSidType type;
42
 
        E2kSid_SID *binary_sid;
43
 
        gchar *string_sid;
44
 
        gchar *display_name;
45
 
};
46
 
 
47
 
#define PARENT_TYPE G_TYPE_OBJECT
48
 
static GObjectClass *parent_class = NULL;
49
 
 
50
 
static void dispose (GObject *object);
51
 
 
52
 
static void
53
 
class_init (GObjectClass *object_class)
54
 
{
55
 
        parent_class = g_type_class_ref (PARENT_TYPE);
56
 
 
57
 
        object_class->dispose = dispose;
58
 
}
59
 
 
60
 
static void
61
 
init (GObject *object)
62
 
{
63
 
        E2kSid *sid = E2K_SID (object);
64
 
 
65
 
        sid->priv = g_new0 (E2kSidPrivate, 1);
66
 
}
67
 
 
68
 
static void
69
 
dispose (GObject *object)
70
 
{
71
 
        E2kSid *sid = E2K_SID (object);
72
 
 
73
 
        if (sid->priv) {
74
 
                if (sid->priv->string_sid)
75
 
                        g_free (sid->priv->string_sid);
76
 
                if (sid->priv->binary_sid)
77
 
                        g_free (sid->priv->binary_sid);
78
 
                g_free (sid->priv->display_name);
79
 
 
80
 
                g_free (sid->priv);
81
 
                sid->priv = NULL;
82
 
        }
83
 
 
84
 
        G_OBJECT_CLASS (parent_class)->dispose (object);
85
 
}
86
 
 
87
 
E2K_MAKE_TYPE (e2k_sid, E2kSid, class_init, init, PARENT_TYPE)
88
 
 
89
 
static E2kSid *
90
 
sid_new_internal (E2kSidType type, const gchar *display_name,
91
 
                  const gchar *string_sid, const guint8 *binary_sid)
92
 
{
93
 
        E2kSid *sid;
94
 
 
95
 
        sid = g_object_new (E2K_TYPE_SID, NULL);
96
 
        sid->priv->type = type;
97
 
 
98
 
        if (binary_sid)
99
 
                sid->priv->binary_sid = g_memdup (binary_sid, E2K_SID_BINARY_SID_LEN (binary_sid));
100
 
        if (string_sid)
101
 
                sid->priv->string_sid = g_strdup (string_sid);
102
 
        else if (!display_name)
103
 
                e2k_sid_get_string_sid (sid);
104
 
 
105
 
        if (!display_name) {
106
 
                if (type == E2K_SID_TYPE_WELL_KNOWN_GROUP) {
107
 
                        if (!strcmp (string_sid, E2K_SID_WKS_ANONYMOUS))
108
 
                                display_name = _(E2K_SID_WKS_ANONYMOUS_NAME);
109
 
                        else if (!strcmp (string_sid, E2K_SID_WKS_EVERYONE))
110
 
                                display_name = _(E2K_SID_WKS_EVERYONE_NAME);
111
 
                }
112
 
                if (!display_name)
113
 
                        display_name = string_sid;
114
 
        }
115
 
        sid->priv->display_name = g_strdup (display_name);
116
 
 
117
 
        return sid;
118
 
}
119
 
 
120
 
/**
121
 
 * e2k_sid_new_from_string_sid:
122
 
 * @type: the type of SID that @string_sid is
123
 
 * @string_sid: the string form of a Windows Security Identifier
124
 
 * @display_name: UTF-8 display name of the user/group/etc identified
125
 
 * by @string_sid
126
 
 *
127
 
 * Creates an %E2kSid from the given information
128
 
 *
129
 
 * Return value: the new SID
130
 
 **/
131
 
E2kSid *
132
 
e2k_sid_new_from_string_sid (E2kSidType type, const gchar *string_sid,
133
 
                             const gchar *display_name)
134
 
{
135
 
        g_return_val_if_fail (string_sid != NULL, NULL);
136
 
 
137
 
        if (strlen (string_sid) < 6 || strncmp (string_sid, "S-1-", 4) != 0)
138
 
                return NULL;
139
 
 
140
 
        return sid_new_internal (type, display_name, string_sid, NULL);
141
 
}
142
 
 
143
 
/**
144
 
 * e2k_sid_new_from_binary_sid:
145
 
 * @type: the type of SID that @binary_sid is
146
 
 * @binary_sid: the binary form of a Windows Security Identifier
147
 
 * @display_name: UTF-8 display name of the user/group/etc identified
148
 
 * by @string_sid
149
 
 *
150
 
 * Creates an %E2kSid from the given information
151
 
 *
152
 
 * Return value: the new SID
153
 
 **/
154
 
E2kSid *
155
 
e2k_sid_new_from_binary_sid (E2kSidType    type,
156
 
                             const guint8 *binary_sid,
157
 
                             const gchar   *display_name)
158
 
{
159
 
        g_return_val_if_fail (binary_sid != NULL, NULL);
160
 
 
161
 
        return sid_new_internal (type, display_name, NULL, binary_sid);
162
 
}
163
 
 
164
 
/**
165
 
 * e2k_sid_get_sid_type:
166
 
 * @sid: a SID
167
 
 *
168
 
 * Returns the type of @sid (user, group, etc)
169
 
 *
170
 
 * Return value: the %E2kSidType
171
 
 **/
172
 
E2kSidType
173
 
e2k_sid_get_sid_type (E2kSid *sid)
174
 
{
175
 
        g_return_val_if_fail (E2K_IS_SID (sid), E2K_SID_TYPE_USER);
176
 
 
177
 
        return sid->priv->type;
178
 
}
179
 
 
180
 
/**
181
 
 * e2k_sid_get_string_sid:
182
 
 * @sid: a SID
183
 
 *
184
 
 * Returns the string form of @sid
185
 
 *
186
 
 * Return value: the string SID
187
 
 **/
188
 
const gchar *
189
 
e2k_sid_get_string_sid (E2kSid *sid)
190
 
{
191
 
        g_return_val_if_fail (E2K_IS_SID (sid), NULL);
192
 
 
193
 
        if (!sid->priv->string_sid) {
194
 
                GString *string;
195
 
                gint sa;
196
 
 
197
 
                string = g_string_new (NULL);
198
 
 
199
 
                /* Revision and IdentifierAuthority. */
200
 
                g_string_append_printf (string, "S-%u-%u",
201
 
                                        sid->priv->binary_sid->Revision,
202
 
                                        sid->priv->binary_sid->IdentifierAuthority);
203
 
 
204
 
                /* Subauthorities. */
205
 
                for (sa = 0; sa < sid->priv->binary_sid->SubAuthorityCount; sa++) {
206
 
                        g_string_append_printf (string, "-%lu",
207
 
                                                (gulong) GUINT32_FROM_LE (sid->priv->binary_sid->SubAuthority[sa]));
208
 
                }
209
 
 
210
 
                sid->priv->string_sid = string->str;
211
 
                g_string_free (string, FALSE);
212
 
        }
213
 
 
214
 
        return sid->priv->string_sid;
215
 
}
216
 
 
217
 
/**
218
 
 * e2k_sid_get_binary_sid:
219
 
 * @sid: a SID
220
 
 *
221
 
 * Returns the binary form of @sid. Since the SID data is self-delimiting,
222
 
 * no length value is needed. Use E2K_SID_BINARY_SID_LEN() if you need to
223
 
 * know the size of the binary data.
224
 
 *
225
 
 * Return value: the binary SID
226
 
 **/
227
 
const guint8 *
228
 
e2k_sid_get_binary_sid (E2kSid *sid)
229
 
{
230
 
        g_return_val_if_fail (E2K_IS_SID (sid), NULL);
231
 
 
232
 
        if (!sid->priv->binary_sid) {
233
 
                gint sa, subauth_count;
234
 
                guint32 subauthority;
235
 
                gchar *p;
236
 
 
237
 
                p = sid->priv->string_sid + 4;
238
 
                subauth_count = 0;
239
 
                while ((p = strchr (p, '-'))) {
240
 
                        subauth_count++;
241
 
                        p++;
242
 
                }
243
 
 
244
 
                sid->priv->binary_sid = g_malloc0 (sizeof (E2kSid_SID) + 4 * (subauth_count - 1));
245
 
                sid->priv->binary_sid->Revision = E2K_SID_SID_REVISION;
246
 
                sid->priv->binary_sid->IdentifierAuthority = strtoul (sid->priv->string_sid + 4, &p, 10);
247
 
                sid->priv->binary_sid->SubAuthorityCount = subauth_count;
248
 
 
249
 
                sa = 0;
250
 
                while (*p == '-' && sa < subauth_count) {
251
 
                        subauthority = strtoul (p + 1, &p, 10);
252
 
                        sid->priv->binary_sid->SubAuthority[sa++] =
253
 
                                GUINT32_TO_LE (subauthority);
254
 
                }
255
 
        }
256
 
 
257
 
        return (guint8 *)sid->priv->binary_sid;
258
 
}
259
 
 
260
 
/**
261
 
 * e2k_sid_get_display_name:
262
 
 * @sid: a SID
263
 
 *
264
 
 * Returns the display name of the entity identified by @sid
265
 
 *
266
 
 * Return value: the UTF-8 display name
267
 
 **/
268
 
const gchar *
269
 
e2k_sid_get_display_name (E2kSid *sid)
270
 
{
271
 
        g_return_val_if_fail (E2K_IS_SID (sid), NULL);
272
 
 
273
 
        return sid->priv->display_name;
274
 
}
275
 
 
276
 
/**
277
 
 * e2k_sid_binary_sid_equal:
278
 
 * @a: pointer to a binary SID
279
 
 * @b: pointer to another binary SID
280
 
 *
281
 
 * Determines if @a and @b contain the same SID data. For use
282
 
 * with #GHashTable.
283
 
 *
284
 
 * Return value: %TRUE or %FALSE
285
 
 **/
286
 
gint
287
 
e2k_sid_binary_sid_equal (gconstpointer a, gconstpointer b)
288
 
{
289
 
        const guint8 *bsida = (const guint8 *)a;
290
 
        const guint8 *bsidb = (const guint8 *)b;
291
 
 
292
 
        if (E2K_SID_BINARY_SID_LEN (bsida) !=
293
 
            E2K_SID_BINARY_SID_LEN (bsidb))
294
 
                return FALSE;
295
 
        return memcmp (bsida, bsidb, E2K_SID_BINARY_SID_LEN (bsida)) == 0;
296
 
}
297
 
 
298
 
/**
299
 
 * e2k_sid_binary_sid_hash:
300
 
 * @key: pointer to a binary SID
301
 
 *
302
 
 * Hashes @key, a binary SID. For use with #GHashTable.
303
 
 *
304
 
 * Return value: the hash value
305
 
 **/
306
 
guint
307
 
e2k_sid_binary_sid_hash (gconstpointer key)
308
 
{
309
 
        const guint8 *bsid = (const guint8 *)key;
310
 
        guint32 final_sa;
311
 
 
312
 
        /* The majority of SIDs will differ only in the last
313
 
         * subauthority value.
314
 
         */
315
 
        memcpy (&final_sa, bsid + E2K_SID_BINARY_SID_LEN (bsid) - 4, 4);
316
 
        return final_sa;
317
 
}