← Back to branch summary

~ubuntu-branches/ubuntu/natty/libvirt/natty

« back to all changes in this revision

Viewing changes to .pc/9026-security-avoid-memory-leak.patch/src/security/security_stack.c

  • Committer: Bazaar Package Importer
  • Author(s): Jamie Strandboge, Serge Hallyn, Jamie Strandboge
  • Date: 2011-03-15 11:46:34 UTC
  • Revision ID: james.westby@ubuntu.com-20110315114634-sirhownqcyy3hbqi
Tags: 0.8.8-1ubuntu4
[ Serge Hallyn ]
* Replace 9024-skip-broken-commandtest.patch with
  9024-fix-broken-commandtest.patch from upstream.

[ Jamie Strandboge ]
* debian/patches/9026-security-avoid-memory-leak.patch: avoid memory leaks
  with the security drivers. Can be dropped in 0.8.9.
* SECURITY UPDATE: debian/patches/9027-CVE-2011-1146.patch: Add missing
  checks for read only connections. Patch from Debian. Can be dropped in
  0.8.8-3.
  - CVE-2011-1146

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/9026-security-avoid-memory-leak.patch/src/security/security_stack.c
 
1
/*
 
2
 * Copyright (C) 2010-2011 Red Hat, Inc.
 
3
 *
 
4
 * This library is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU Lesser General Public
 
6
 * License as published by the Free Software Foundation; either
 
7
 * version 2.1 of the License, or (at your option) any later version.
 
8
 *
 
9
 * This library 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
 * Lesser 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 library; if not, write to the Free Software
 
16
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 
17
 *
 
18
 * Stacked security driver
 
19
 */
 
20
 
 
21
#include <config.h>
 
22
 
 
23
#include "security_stack.h"
 
24
 
 
25
#include "virterror_internal.h"
 
26
 
 
27
#define VIR_FROM_THIS VIR_FROM_SECURITY
 
28
 
 
29
typedef struct _virSecurityStackData virSecurityStackData;
 
30
typedef virSecurityStackData *virSecurityStackDataPtr;
 
31
 
 
32
struct _virSecurityStackData {
 
33
    virSecurityManagerPtr primary;
 
34
    virSecurityManagerPtr secondary;
 
35
};
 
36
 
 
37
void virSecurityStackSetPrimary(virSecurityManagerPtr mgr,
 
38
                                virSecurityManagerPtr primary)
 
39
{
 
40
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
41
    priv->primary = primary;
 
42
}
 
43
 
 
44
void virSecurityStackSetSecondary(virSecurityManagerPtr mgr,
 
45
                                  virSecurityManagerPtr secondary)
 
46
{
 
47
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
48
    priv->secondary = secondary;
 
49
}
 
50
 
 
51
static virSecurityDriverStatus
 
52
virSecurityStackProbe(void)
 
53
{
 
54
    return SECURITY_DRIVER_ENABLE;
 
55
}
 
56
 
 
57
static int
 
58
virSecurityStackOpen(virSecurityManagerPtr mgr ATTRIBUTE_UNUSED)
 
59
{
 
60
    return 0;
 
61
}
 
62
 
 
63
static int
 
64
virSecurityStackClose(virSecurityManagerPtr mgr ATTRIBUTE_UNUSED)
 
65
{
 
66
    return 0;
 
67
}
 
68
 
 
69
static const char *
 
70
virSecurityStackGetModel(virSecurityManagerPtr mgr)
 
71
{
 
72
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
73
 
 
74
    return virSecurityManagerGetModel(priv->primary);
 
75
}
 
76
 
 
77
static const char *
 
78
virSecurityStackGetDOI(virSecurityManagerPtr mgr)
 
79
{
 
80
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
81
 
 
82
    return virSecurityManagerGetDOI(priv->primary);
 
83
}
 
84
 
 
85
static int
 
86
virSecurityStackVerify(virSecurityManagerPtr mgr,
 
87
                       virDomainDefPtr def)
 
88
{
 
89
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
90
    int rc = 0;
 
91
 
 
92
    if (virSecurityManagerVerify(priv->primary, def) < 0)
 
93
        rc = -1;
 
94
 
 
95
    if (virSecurityManagerVerify(priv->secondary, def) < 0)
 
96
        rc = -1;
 
97
 
 
98
    return rc;
 
99
}
 
100
 
 
101
 
 
102
static int
 
103
virSecurityStackGenLabel(virSecurityManagerPtr mgr,
 
104
                         virDomainObjPtr vm)
 
105
{
 
106
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
107
    int rc = 0;
 
108
 
 
109
    if (virSecurityManagerGenLabel(priv->primary, vm) < 0)
 
110
        rc = -1;
 
111
 
 
112
#if 0
 
113
    /* We don't allow secondary drivers to generate labels.
 
114
     * This may have to change in the future, but requires
 
115
     * changes elsewhere in domain_conf.c and capabilities.c
 
116
     * XML formats first, to allow recording of multiple
 
117
     * labels
 
118
     */
 
119
    if (virSecurityManagerGenLabel(priv->secondary, vm) < 0)
 
120
        rc = -1;
 
121
#endif
 
122
 
 
123
    return rc;
 
124
}
 
125
 
 
126
 
 
127
static int
 
128
virSecurityStackReleaseLabel(virSecurityManagerPtr mgr,
 
129
                             virDomainObjPtr vm)
 
130
{
 
131
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
132
    int rc = 0;
 
133
 
 
134
    if (virSecurityManagerReleaseLabel(priv->primary, vm) < 0)
 
135
        rc = -1;
 
136
#if 0
 
137
    /* XXX See note in GenLabel */
 
138
    if (virSecurityManagerReleaseLabel(priv->secondary, vm) < 0)
 
139
        rc = -1;
 
140
#endif
 
141
 
 
142
    return rc;
 
143
}
 
144
 
 
145
 
 
146
static int
 
147
virSecurityStackReserveLabel(virSecurityManagerPtr mgr,
 
148
                             virDomainObjPtr vm)
 
149
{
 
150
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
151
    int rc = 0;
 
152
 
 
153
    if (virSecurityManagerReserveLabel(priv->primary, vm) < 0)
 
154
        rc = -1;
 
155
#if 0
 
156
    /* XXX See note in GenLabel */
 
157
    if (virSecurityManagerReserveLabel(priv->secondary, vm) < 0)
 
158
        rc = -1;
 
159
#endif
 
160
 
 
161
    return rc;
 
162
}
 
163
 
 
164
 
 
165
static int
 
166
virSecurityStackSetSecurityImageLabel(virSecurityManagerPtr mgr,
 
167
                                      virDomainObjPtr vm,
 
168
                                      virDomainDiskDefPtr disk)
 
169
{
 
170
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
171
    int rc = 0;
 
172
 
 
173
    if (virSecurityManagerSetImageLabel(priv->secondary, vm, disk) < 0)
 
174
        rc = -1;
 
175
    if (virSecurityManagerSetImageLabel(priv->primary, vm, disk) < 0)
 
176
        rc = -1;
 
177
 
 
178
    return rc;
 
179
}
 
180
 
 
181
 
 
182
static int
 
183
virSecurityStackRestoreSecurityImageLabel(virSecurityManagerPtr mgr,
 
184
                                          virDomainObjPtr vm,
 
185
                                          virDomainDiskDefPtr disk)
 
186
{
 
187
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
188
    int rc = 0;
 
189
 
 
190
    if (virSecurityManagerRestoreImageLabel(priv->secondary, vm, disk) < 0)
 
191
        rc = -1;
 
192
    if (virSecurityManagerRestoreImageLabel(priv->primary, vm, disk) < 0)
 
193
        rc = -1;
 
194
 
 
195
    return rc;
 
196
}
 
197
 
 
198
 
 
199
static int
 
200
virSecurityStackSetSecurityHostdevLabel(virSecurityManagerPtr mgr,
 
201
                                        virDomainObjPtr vm,
 
202
                                        virDomainHostdevDefPtr dev)
 
203
 
 
204
{
 
205
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
206
    int rc = 0;
 
207
 
 
208
    if (virSecurityManagerSetHostdevLabel(priv->secondary, vm, dev) < 0)
 
209
        rc = -1;
 
210
    if (virSecurityManagerSetHostdevLabel(priv->primary, vm, dev) < 0)
 
211
        rc = -1;
 
212
 
 
213
    return rc;
 
214
}
 
215
 
 
216
 
 
217
static int
 
218
virSecurityStackRestoreSecurityHostdevLabel(virSecurityManagerPtr mgr,
 
219
                                            virDomainObjPtr vm,
 
220
                                            virDomainHostdevDefPtr dev)
 
221
{
 
222
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
223
    int rc = 0;
 
224
 
 
225
    if (virSecurityManagerRestoreHostdevLabel(priv->secondary, vm, dev) < 0)
 
226
        rc = -1;
 
227
    if (virSecurityManagerRestoreHostdevLabel(priv->primary, vm, dev) < 0)
 
228
        rc = -1;
 
229
 
 
230
    return rc;
 
231
}
 
232
 
 
233
 
 
234
static int
 
235
virSecurityStackSetSecurityAllLabel(virSecurityManagerPtr mgr,
 
236
                                    virDomainObjPtr vm,
 
237
                                    const char *stdin_path)
 
238
{
 
239
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
240
    int rc = 0;
 
241
 
 
242
    if (virSecurityManagerSetAllLabel(priv->secondary, vm, stdin_path) < 0)
 
243
        rc = -1;
 
244
    if (virSecurityManagerSetAllLabel(priv->primary, vm, stdin_path) < 0)
 
245
        rc = -1;
 
246
 
 
247
    return rc;
 
248
}
 
249
 
 
250
 
 
251
static int
 
252
virSecurityStackRestoreSecurityAllLabel(virSecurityManagerPtr mgr,
 
253
                                        virDomainObjPtr vm,
 
254
                                        int migrated)
 
255
{
 
256
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
257
    int rc = 0;
 
258
 
 
259
    if (virSecurityManagerRestoreAllLabel(priv->secondary, vm, migrated) < 0)
 
260
        rc = -1;
 
261
    if (virSecurityManagerRestoreAllLabel(priv->primary, vm, migrated) < 0)
 
262
        rc = -1;
 
263
 
 
264
    return rc;
 
265
}
 
266
 
 
267
 
 
268
static int
 
269
virSecurityStackSetSavedStateLabel(virSecurityManagerPtr mgr,
 
270
                                   virDomainObjPtr vm,
 
271
                                   const char *savefile)
 
272
{
 
273
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
274
    int rc = 0;
 
275
 
 
276
    if (virSecurityManagerSetSavedStateLabel(priv->secondary, vm, savefile) < 0)
 
277
        rc = -1;
 
278
    if (virSecurityManagerSetSavedStateLabel(priv->primary, vm, savefile) < 0)
 
279
        rc = -1;
 
280
 
 
281
    return rc;
 
282
}
 
283
 
 
284
 
 
285
static int
 
286
virSecurityStackRestoreSavedStateLabel(virSecurityManagerPtr mgr,
 
287
                                       virDomainObjPtr vm,
 
288
                                       const char *savefile)
 
289
{
 
290
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
291
    int rc = 0;
 
292
 
 
293
    if (virSecurityManagerRestoreSavedStateLabel(priv->secondary, vm, savefile) < 0)
 
294
        rc = -1;
 
295
    if (virSecurityManagerRestoreSavedStateLabel(priv->primary, vm, savefile) < 0)
 
296
        rc = -1;
 
297
 
 
298
    return rc;
 
299
}
 
300
 
 
301
 
 
302
static int
 
303
virSecurityStackSetProcessLabel(virSecurityManagerPtr mgr,
 
304
                                virDomainObjPtr vm)
 
305
{
 
306
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
307
    int rc = 0;
 
308
 
 
309
    if (virSecurityManagerSetProcessLabel(priv->secondary, vm) < 0)
 
310
        rc = -1;
 
311
    if (virSecurityManagerSetProcessLabel(priv->primary, vm) < 0)
 
312
        rc = -1;
 
313
 
 
314
    return rc;
 
315
}
 
316
 
 
317
static int
 
318
virSecurityStackGetProcessLabel(virSecurityManagerPtr mgr,
 
319
                                virDomainObjPtr vm,
 
320
                                virSecurityLabelPtr seclabel)
 
321
{
 
322
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
323
    int rc = 0;
 
324
 
 
325
#if 0
 
326
    if (virSecurityManagerGetProcessLabel(priv->secondary, vm, seclabel) < 0)
 
327
        rc = -1;
 
328
#endif
 
329
    if (virSecurityManagerGetProcessLabel(priv->primary, vm, seclabel) < 0)
 
330
        rc = -1;
 
331
 
 
332
    return rc;
 
333
}
 
334
 
 
335
 
 
336
static int
 
337
virSecurityStackSetSocketLabel(virSecurityManagerPtr mgr,
 
338
                               virDomainObjPtr vm)
 
339
{
 
340
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
341
    int rc = 0;
 
342
 
 
343
    if (virSecurityManagerSetSocketLabel(priv->secondary, vm) < 0)
 
344
        rc = -1;
 
345
    if (virSecurityManagerSetSocketLabel(priv->primary, vm) < 0)
 
346
        rc = -1;
 
347
 
 
348
    return rc;
 
349
}
 
350
 
 
351
 
 
352
static int
 
353
virSecurityStackClearSocketLabel(virSecurityManagerPtr mgr,
 
354
                                 virDomainObjPtr vm)
 
355
{
 
356
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
357
    int rc = 0;
 
358
 
 
359
    if (virSecurityManagerClearSocketLabel(priv->secondary, vm) < 0)
 
360
        rc = -1;
 
361
    if (virSecurityManagerClearSocketLabel(priv->primary, vm) < 0)
 
362
        rc = -1;
 
363
 
 
364
    return rc;
 
365
}
 
366
 
 
367
static int
 
368
virSecurityStackSetFDLabel(virSecurityManagerPtr mgr,
 
369
                           virDomainObjPtr vm,
 
370
                           int fd)
 
371
{
 
372
    virSecurityStackDataPtr priv = virSecurityManagerGetPrivateData(mgr);
 
373
    int rc = 0;
 
374
 
 
375
    if (virSecurityManagerSetFDLabel(priv->secondary, vm, fd) < 0)
 
376
        rc = -1;
 
377
    if (virSecurityManagerSetFDLabel(priv->primary, vm, fd) < 0)
 
378
        rc = -1;
 
379
 
 
380
    return rc;
 
381
}
 
382
 
 
383
 
 
384
virSecurityDriver virSecurityDriverStack = {
 
385
    sizeof(virSecurityStackData),
 
386
    "stack",
 
387
    virSecurityStackProbe,
 
388
    virSecurityStackOpen,
 
389
    virSecurityStackClose,
 
390
 
 
391
    virSecurityStackGetModel,
 
392
    virSecurityStackGetDOI,
 
393
 
 
394
    virSecurityStackVerify,
 
395
 
 
396
    virSecurityStackSetSecurityImageLabel,
 
397
    virSecurityStackRestoreSecurityImageLabel,
 
398
 
 
399
    virSecurityStackSetSocketLabel,
 
400
    virSecurityStackClearSocketLabel,
 
401
 
 
402
    virSecurityStackGenLabel,
 
403
    virSecurityStackReserveLabel,
 
404
    virSecurityStackReleaseLabel,
 
405
 
 
406
    virSecurityStackGetProcessLabel,
 
407
    virSecurityStackSetProcessLabel,
 
408
 
 
409
    virSecurityStackSetSecurityAllLabel,
 
410
    virSecurityStackRestoreSecurityAllLabel,
 
411
 
 
412
    virSecurityStackSetSecurityHostdevLabel,
 
413
    virSecurityStackRestoreSecurityHostdevLabel,
 
414
 
 
415
    virSecurityStackSetSavedStateLabel,
 
416
    virSecurityStackRestoreSavedStateLabel,
 
417
 
 
418
    virSecurityStackSetFDLabel,
 
419
};