← Back to branch summary

~ubuntu-branches/ubuntu/karmic/openafs/karmic-updates

« back to all changes in this revision

Viewing changes to src/bucoord/vol_sets.c

  • Committer: Bazaar Package Importer
  • Author(s): Russ Allbery
  • Date: 2008-09-22 19:07:02 UTC
  • mfrom: (12.1.14 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080922190702-59m13d7kn6gkw32d
Tags: 1.4.7.dfsg1-6
http://bugs.debian.org/493914
https://launchpad.net/bugs/267504
http://bugs.debian.org/493120
* Apply upstream patch to free /proc entries in the correct order.
  Thanks, Marc Dionne.  (Closes: #493914)
* Apply upstream deltas to support 2.6.27 kernels and to stop using
  COMMON_KERN_CFLAGS for all 2.6 kernels uniformly, which fixes
  problems on amd64 with newer kernels.  Thanks, Björn Torkelsson.
  (LP: #267504)
* Translation updates:
  - Swedish, thanks Martin Bagge.  (Closes: #493120)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/bucoord/vol_sets.c
11
11
#include <afs/param.h>
12
12
 
13
13
RCSID
14
 
    ("$Header: /cvs/openafs/src/bucoord/vol_sets.c,v 1.10.2.2 2006/07/31 17:07:49 shadow Exp $");
 
14
    ("$Header: /cvs/openafs/src/bucoord/vol_sets.c,v 1.10.2.6 2007/11/26 21:21:50 shadow Exp $");
15
15
 
16
16
#include <afs/stds.h>
17
17
#include <sys/types.h>
18
 
#include <stdio.h>
19
18
#ifdef AFS_NT40_ENV
20
19
#include <winsock2.h>
21
20
#else
42
41
extern struct bc_volumeSet *bc_FindVolumeSet(struct bc_config *cf, char *name);
43
42
extern void FreeVolumeSet(struct bc_volumeSet *avset);
44
43
 
 
44
static ListVolSet();
45
45
 
46
46
/* ------------------------------------
47
47
 * command level routines
58
58
 *      parm 3 is volume regexp
59
59
 */
60
60
 
61
 
bc_AddVolEntryCmd(as, arock)
62
 
     struct cmd_syndesc *as;
63
 
     char *arock;
 
61
int
 
62
bc_AddVolEntryCmd(struct cmd_syndesc *as, void *arock)
64
63
{
65
 
    register afs_int32 code;
 
64
    register int code;
66
65
    char *volSetName, *serverName, *partitionName, *volRegExp;
67
66
    udbClientTextP ctPtr;
68
67
    struct bc_volumeSet *tset;
74
73
 
75
74
    code = bc_UpdateVolumeSet();
76
75
    if (code) {
77
 
        com_err(whoami, code, "; Can't retrieve volume sets");
 
76
        afs_com_err(whoami, code, "; Can't retrieve volume sets");
78
77
        return (code);
79
78
    }
80
79
 
82
81
 
83
82
    tset = bc_FindVolumeSet(bc_globalConfig, volSetName);
84
83
    if (!tset) {
85
 
        com_err(whoami, code, "; Volume entry not added");
 
84
        afs_com_err(whoami, code, "; Volume entry not added");
86
85
        ERROR(code);
87
86
    }
88
87
 
94
93
 
95
94
    code = bc_UpdateVolumeSet();
96
95
    if (code) {
97
 
        com_err(whoami, code, "; Can't retrieve volume sets");
 
96
        afs_com_err(whoami, code, "; Can't retrieve volume sets");
98
97
        return (code);
99
98
    }
100
99
 
102
101
        bc_AddVolumeItem(bc_globalConfig, volSetName, serverName,
103
102
                         partitionName, volRegExp);
104
103
    if (code) {
105
 
        com_err(whoami, code, "; Volume entry not added");
 
104
        afs_com_err(whoami, code, "; Volume entry not added");
106
105
        ERROR(code);
107
106
    }
108
107
 
109
108
    if (!(tset->flags & VSFLAG_TEMPORARY)) {
110
109
        code = bc_SaveVolumeSet();
111
110
        if (code) {
112
 
            com_err(whoami, code, "Cannot save volume set file");
113
 
            com_err(whoami, 0,
 
111
            afs_com_err(whoami, code, "Cannot save volume set file");
 
112
            afs_com_err(whoami, 0,
114
113
                    "Changes are temporary - for this session only");
115
114
        }
116
115
    }
130
129
 *      name of new volume set
131
130
 */
132
131
 
133
 
afs_int32
134
 
bc_AddVolSetCmd(as, arock)
135
 
     struct cmd_syndesc *as;
136
 
     char *arock;
 
132
int
 
133
bc_AddVolSetCmd(struct cmd_syndesc *as, void *arock)
137
134
{
138
135
    /* parm 0 is vol set name */
139
 
    register afs_int32 code;
 
136
    register int code;
140
137
    register struct cmd_item *ti;
141
138
    udbClientTextP ctPtr;
142
139
    afs_int32 flags;
155
152
 
156
153
    code = bc_UpdateVolumeSet();
157
154
    if (code) {
158
 
        com_err(whoami, code, "; Can't retrieve volume sets");
 
155
        afs_com_err(whoami, code, "; Can't retrieve volume sets");
159
156
        return (code);
160
157
    }
161
158
 
165
162
                           flags);
166
163
    if (code) {
167
164
        if (code == -1)
168
 
            com_err(whoami, 0, "Volume set '%s' already exists", ti->data);
 
165
            afs_com_err(whoami, 0, "Volume set '%s' already exists", ti->data);
169
166
        else
170
 
            com_err(whoami, 0, "Unknown problem");
 
167
            afs_com_err(whoami, 0, "Unknown problem");
171
168
    } else if (!(flags & VSFLAG_TEMPORARY)) {
172
169
        code = bc_SaveVolumeSet();
173
170
        if (code) {
174
 
            com_err(whoami, code, "Cannot save new volume set file");
175
 
            com_err(whoami, 0,
 
171
            afs_com_err(whoami, code, "Cannot save new volume set file");
 
172
            afs_com_err(whoami, 0,
176
173
                    "Changes are temporary - for this session only");
177
174
        }
178
175
    }
191
188
 *      parm 1 is entry # (integer, 1 based)
192
189
 */
193
190
 
194
 
afs_int32
195
 
bc_DeleteVolEntryCmd(as, arock)
196
 
     struct cmd_syndesc *as;
197
 
     char *arock;
 
191
int
 
192
bc_DeleteVolEntryCmd(struct cmd_syndesc *as, void *arock)
198
193
{
199
 
    register afs_int32 code;
 
194
    register int code;
200
195
    afs_int32 entry;
201
196
    char *vsname;
202
197
    udbClientTextP ctPtr;
206
201
 
207
202
    code = bc_UpdateVolumeSet();
208
203
    if (code) {
209
 
        com_err(whoami, code, "; Can't retrieve volume sets");
 
204
        afs_com_err(whoami, code, "; Can't retrieve volume sets");
210
205
        return (code);
211
206
    }
212
207
 
215
210
 
216
211
    tset = bc_FindVolumeSet(bc_globalConfig, vsname);
217
212
    if (!tset) {
218
 
        com_err(whoami, 0, "No such volume set as '%s'", vsname);
 
213
        afs_com_err(whoami, 0, "No such volume set as '%s'", vsname);
219
214
        ERROR(code);
220
215
    }
221
216
 
227
222
 
228
223
    code = bc_UpdateVolumeSet();
229
224
    if (code) {
230
 
        com_err(whoami, code, "; Can't retrieve volume sets");
 
225
        afs_com_err(whoami, code, "; Can't retrieve volume sets");
231
226
        return (code);
232
227
    }
233
228
 
234
229
    entry = bc_SafeATOI(as->parms[1].items->data);
235
230
    if (entry < 0) {
236
 
        com_err(whoami, 0, "Can't parse entry number '%s' as decimal integer",
 
231
        afs_com_err(whoami, 0, "Can't parse entry number '%s' as decimal integer",
237
232
                as->parms[1].items->data);
238
233
        ERROR(BC_BADARG);
239
234
    }
241
236
    code = bc_DeleteVolumeItem(bc_globalConfig, vsname, entry);
242
237
    if (code) {
243
238
        if (code == -1) {
244
 
            com_err(whoami, 0, "No such volume set as '%s'", vsname);
 
239
            afs_com_err(whoami, 0, "No such volume set as '%s'", vsname);
245
240
        } else if (code == -2) {
246
 
            com_err(whoami, 0,
 
241
            afs_com_err(whoami, 0,
247
242
                    "There aren't %d volume items for this volume set",
248
243
                    entry);
249
 
            com_err(whoami, 0,
 
244
            afs_com_err(whoami, 0,
250
245
                    "Use the 'listvolsets' command to examine the volume set");
251
246
        }
252
247
        ERROR(code);
258
253
            printf("backup: deleted volume entry %d from volume set %s\n",
259
254
                   entry, vsname);
260
255
        } else {
261
 
            com_err(whoami, code, "Cannot save volume set file");
262
 
            com_err(whoami, 0,
 
256
            afs_com_err(whoami, code, "Cannot save volume set file");
 
257
            afs_com_err(whoami, 0,
263
258
                    "Deletion is temporary - for this session only");
264
259
        }
265
260
    }
280
275
 *      name of volumeset to delete
281
276
 */
282
277
 
283
 
afs_int32
284
 
bc_DeleteVolSetCmd(as, arock)
285
 
     struct cmd_syndesc *as;
286
 
     char *arock;
 
278
int
 
279
bc_DeleteVolSetCmd(struct cmd_syndesc *as, void *arock)
287
280
{
288
281
    /* parm 0 is vol set name */
289
 
    register afs_int32 code;
 
282
    register int code;
290
283
    register struct cmd_item *ti;
291
284
    udbClientTextP ctPtr;
292
285
    afs_int32 c;
301
294
 
302
295
    code = bc_UpdateVolumeSet();
303
296
    if (code) {
304
 
        com_err(whoami, code, "; Can't retrieve volume sets");
 
297
        afs_com_err(whoami, code, "; Can't retrieve volume sets");
305
298
        return (code);
306
299
    }
307
300
 
309
302
        code = bc_DeleteVolumeSet(bc_globalConfig, ti->data, &flags);
310
303
        if (code) {
311
304
            if (code == -1)
312
 
                com_err(whoami, 0, "Can't find volume set '%s'", ti->data);
 
305
                afs_com_err(whoami, 0, "Can't find volume set '%s'", ti->data);
313
306
            else
314
 
                com_err(whoami, code,
 
307
                afs_com_err(whoami, code,
315
308
                        "; Unknown problem deleting volume set '%s'",
316
309
                        ti->data);
317
310
        } else {
327
320
        if (c) {
328
321
            if (!code)
329
322
                code = c;
330
 
            com_err(whoami, c, "Cannot save updated volume set file");
331
 
            com_err(whoami, 0, "Deletion effective for this session only");
 
323
            afs_com_err(whoami, c, "Cannot save updated volume set file");
 
324
            afs_com_err(whoami, 0, "Deletion effective for this session only");
332
325
        }
333
326
 
334
327
    }
365
358
  *     optional parameter specifies a volumeset name
366
359
  */
367
360
 
368
 
afs_int32
369
 
bc_ListVolSetCmd(struct cmd_syndesc *as, char *arock)
 
361
int
 
362
bc_ListVolSetCmd(struct cmd_syndesc *as, void *arock)
370
363
{
371
364
    /* parm 0 is optional volume set to display */
372
365
    register struct bc_volumeSet *tset;
373
366
    register struct cmd_item *ti;
374
 
    afs_int32 code = 0;
 
367
    int code = 0;
375
368
 
376
369
    code = bc_UpdateVolumeSet();
377
370
    if (code) {
378
 
        com_err(whoami, code, "; Can't retrieve volume sets");
 
371
        afs_com_err(whoami, code, "; Can't retrieve volume sets");
379
372
        return (code);
380
373
    }
381
374
 
388
381
                ListVolSet(tset);
389
382
                printf("\n");
390
383
            } else {
391
 
                com_err(whoami, 0, "Can't find volume set '%s'", ti->data);
 
384
                afs_com_err(whoami, 0, "Can't find volume set '%s'", ti->data);
392
385
                code = 1;
393
386
            }
394
387
        }
496
489
            if ((code != 2)
497
490
                || (strcmp(serverName, "volumeset") != 0)
498
491
                ) {
499
 
                com_err(whoami, 0, "Bad volume header line: '%s'", tbuffer);
 
492
                afs_com_err(whoami, 0, "Bad volume header line: '%s'", tbuffer);
500
493
                return (-1);
501
494
            }
502
495
 
535
528
            tve = (struct bc_volumeEntry *)
536
529
                malloc(sizeof(struct bc_volumeEntry));
537
530
            if (!tve) {
538
 
                com_err(whoami, 0,
 
531
                afs_com_err(whoami, 0,
539
532
                        "Can't malloc() a new volume spec record!");
540
533
                return (-1);
541
534
            }
542
535
            memset(tve, 0, sizeof(*tve));
543
536
            if (bc_ParseHost(serverName, &(tve->server)))
544
 
                com_err(whoami, 0, "Can't get required info on host '%s'",
 
537
                afs_com_err(whoami, 0, "Can't get required info on host '%s'",
545
538
                        serverName);
546
539
 
547
540
            /* The above code has filled in the server sockaddr, now fill in
549
542
             */
550
543
            tve->serverName = (char *)malloc(strlen(serverName) + 1);
551
544
            if (!tve->serverName) {
552
 
                com_err(whoami, 0,
 
545
                afs_com_err(whoami, 0,
553
546
                        "Can't malloc() a new volume spec server name field!");
554
547
                return (-1);
555
548
            }
556
549
            strcpy(tve->serverName, serverName);
557
550
            tve->partname = (char *)malloc(strlen(partName) + 1);
558
551
            if (!tve->partname) {
559
 
                com_err(whoami, 0,
 
552
                afs_com_err(whoami, 0,
560
553
                        "Can't malloc() a new volume spec partition pattern field!");
561
554
                return (-1);
562
555
            }
563
556
            strcpy(tve->partname, partName);
564
557
            code = bc_GetPartitionID(partName, &tve->partition);
565
558
            if (code) {
566
 
                com_err(whoami, 0, "Can't parse partition '%s'", partName);
 
559
                afs_com_err(whoami, 0, "Can't parse partition '%s'", partName);
567
560
                return -1;
568
561
            }
569
562
            tp = (char *)malloc(strlen(vsname) + 1);
570
563
            if (!tp) {
571
 
                com_err(whoami, 0,
 
564
                afs_com_err(whoami, 0,
572
565
                        "Can't malloc() a new volume spec volume pattern field!");
573
566
                return (-1);
574
567
            }