← Back to branch summary

~serge-hallyn/ubuntu/natty/lxc/lxc-fix-3bugs

« back to all changes in this revision

Viewing changes to src/lxc/confile.c

  • Committer: Bazaar Package Importer
  • Author(s): Guido Trotter, Stéphane Graber, Guido Trotter
  • Date: 2010-01-10 10:40:21 UTC
  • mfrom: (1.1.2 upstream) (3.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100110104021-z8rj5zw5mlvra08l
Tags: 0.6.4-1
[ Stéphane Graber ]
* Upgrade standards-version to 3.8.3
* Drop the copy of etc/* from rules as "etc" is no longer in the tarball

[ Guido Trotter ]
* New Upstream Version
* Update libcap2-dev dependency to libcap-dev
* Install upstream-built man pages via debian/lxc.manpages
* Drop unneeded docbook-utils build dependency

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lxc/confile.c
34
34
 
35
35
#include "parse.h"
36
36
 
37
 
#include <lxc/lxc.h>
38
37
#include <lxc/log.h>
 
38
#include <lxc/conf.h>
39
39
 
40
40
lxc_log_define(lxc_confile, lxc);
41
41
 
94
94
 
95
95
static int config_network_type(const char *key, char *value, struct lxc_conf *lxc_conf)
96
96
{
97
 
        struct lxc_list *networks = &lxc_conf->networks;
98
 
        struct lxc_network *network;
 
97
        struct lxc_list *network = &lxc_conf->network;
99
98
        struct lxc_netdev *netdev;
100
99
        struct lxc_list *list;
101
 
        struct lxc_list *ndlist;
102
 
 
103
 
        network = malloc(sizeof(*network));
104
 
        if (!network) {
105
 
                SYSERROR("failed to allocate memory");
106
 
                return -1;
107
 
        }
108
 
 
109
 
        lxc_list_init(&network->netdev);
110
100
 
111
101
        netdev = malloc(sizeof(*netdev));
112
102
        if (!netdev) {
114
104
                return -1;
115
105
        }
116
106
 
 
107
        memset(netdev, 0, sizeof(*netdev));
117
108
        lxc_list_init(&netdev->ipv4);
118
109
        lxc_list_init(&netdev->ipv6);
119
 
        lxc_list_init(&netdev->route4);
120
 
        lxc_list_init(&netdev->route6);
121
 
 
122
 
        ndlist = malloc(sizeof(*ndlist));
123
 
        if (!ndlist) {
124
 
                SYSERROR("failed to allocate memory");
125
 
                return -1;
126
 
        }
127
 
 
128
 
        ndlist->elem = netdev;
129
 
 
130
 
        lxc_list_add(&network->netdev, ndlist);
131
110
 
132
111
        list = malloc(sizeof(*list));
133
112
        if (!list) {
136
115
        }
137
116
 
138
117
        lxc_list_init(list);
139
 
        list->elem = network;
 
118
        list->elem = netdev;
140
119
 
141
 
        lxc_list_add(networks, list);
 
120
        lxc_list_add(network, list);
142
121
 
143
122
        if (!strcmp(value, "veth"))
144
 
                network->type = VETH;
 
123
                netdev->type = VETH;
145
124
        else if (!strcmp(value, "macvlan"))
146
 
                network->type = MACVLAN;
 
125
                netdev->type = MACVLAN;
147
126
        else if (!strcmp(value, "phys"))
148
 
                network->type = PHYS;
 
127
                netdev->type = PHYS;
149
128
        else if (!strcmp(value, "empty"))
150
 
                network->type = EMPTY;
 
129
                netdev->type = EMPTY;
151
130
        else {
152
131
                ERROR("invalid network type %s", value);
153
132
                return -1;
155
134
        return 0;
156
135
}
157
136
 
158
 
static int config_network_flags(const char *key, char *value, struct lxc_conf *lxc_conf)
159
 
{
160
 
        struct lxc_list *networks = &lxc_conf->networks;
161
 
        struct lxc_network *network;
162
 
        struct lxc_netdev *netdev;
163
 
 
164
 
        if (lxc_list_empty(networks)) {
165
 
                ERROR("network is not created for '%s' option", value);
166
 
                return -1;
167
 
        }
168
 
 
169
 
        network = lxc_list_first_elem(networks);
170
 
        if (!network) {
171
 
                ERROR("no network defined for '%s' option", value);
172
 
                return -1;
173
 
        }
174
 
 
175
 
        netdev = lxc_list_first_elem(&network->netdev);
 
137
static int config_ip_prefix(struct in_addr *addr)
 
138
{
 
139
        if (IN_CLASSA(addr->s_addr))
 
140
                return 32 - IN_CLASSA_NSHIFT;
 
141
        if (IN_CLASSB(addr->s_addr))
 
142
                return 32 - IN_CLASSB_NSHIFT;
 
143
        if (IN_CLASSC(addr->s_addr))
 
144
                return 32 - IN_CLASSC_NSHIFT;
 
145
 
 
146
        return 0;
 
147
}
 
148
 
 
149
static struct lxc_netdev *network_netdev(const char *key, const char *value,
 
150
                                         struct lxc_list *network)
 
151
{
 
152
        struct lxc_netdev *netdev;
 
153
 
 
154
        if (lxc_list_empty(network)) {
 
155
                ERROR("network is not created for '%s' = '%s' option",
 
156
                      key, value);
 
157
                return NULL;
 
158
        }
 
159
 
 
160
        netdev = lxc_list_first_elem(network);
 
161
        if (!netdev) {
 
162
                ERROR("no network device defined for '%s' = '%s' option",
 
163
                      key, value);
 
164
                return NULL;
 
165
        }
 
166
 
 
167
        return netdev;
 
168
}
 
169
 
 
170
static int network_ifname(char **valuep, char *value)
 
171
{
 
172
        if (strlen(value) > IFNAMSIZ) {
 
173
                ERROR("invalid interface name: %s", value);
 
174
                return -1;
 
175
        }
 
176
 
 
177
        *valuep = strdup(value);
 
178
        if (!*valuep) {
 
179
                ERROR("failed to dup string '%s'", value);
 
180
                return -1;
 
181
        }
 
182
 
 
183
        return 0;
 
184
}
 
185
 
 
186
static int config_network_flags(const char *key, char *value,
 
187
                                struct lxc_conf *lxc_conf)
 
188
{
 
189
        struct lxc_netdev *netdev;
 
190
 
 
191
        netdev = network_netdev(key, value, &lxc_conf->network);
 
192
        if (!netdev)
 
193
                return -1;
 
194
 
176
195
        netdev->flags |= IFF_UP;
177
 
        return 0;
178
 
}
179
 
 
180
 
static int config_network_link(const char *key, char *value, struct lxc_conf *lxc_conf)
181
 
{
182
 
        struct lxc_list *networks = &lxc_conf->networks;
183
 
        struct lxc_network *network;
184
 
        struct lxc_netdev *netdev;
185
 
 
186
 
        if (lxc_list_empty(networks)) {
187
 
                ERROR("network is not created for %s", value);
188
 
                return -1;
189
 
        }
190
 
 
191
 
        network = lxc_list_first_elem(networks);
192
 
        if (!network) {
193
 
                ERROR("no network defined for %s", value);
194
 
                return -1;
195
 
        }
196
 
 
197
 
        if (strlen(value) > IFNAMSIZ) {
198
 
                ERROR("invalid interface name: %s", value);
199
 
                return -1;
200
 
        }
201
 
 
202
 
        netdev = lxc_list_first_elem(&network->netdev);
203
 
        netdev->ifname = strdup(value);
204
 
        return 0;
205
 
}
206
 
 
207
 
static int config_network_name(const char *key, char *value, struct lxc_conf *lxc_conf)
208
 
{
209
 
        struct lxc_list *networks = &lxc_conf->networks;
210
 
        struct lxc_network *network;
211
 
        struct lxc_netdev *netdev;
212
 
 
213
 
        if (lxc_list_empty(networks)) {
214
 
                ERROR("network is not created for %s", value);
215
 
                return -1;
216
 
        }
217
 
 
218
 
        network = lxc_list_first_elem(networks);
219
 
        if (!network) {
220
 
                ERROR("no network defined for %s", value);
221
 
                return -1;
222
 
        }
223
 
 
224
 
        if (strlen(value) > IFNAMSIZ) {
225
 
                ERROR("invalid interface name: %s", value);
226
 
                return -1;
227
 
        }
228
 
 
229
 
        netdev = lxc_list_first_elem(&network->netdev);
230
 
        netdev->newname = strdup(value);
231
 
        return 0;
232
 
}
233
 
 
234
 
static int config_network_hwaddr(const char *key, char *value, struct lxc_conf *lxc_conf)
235
 
{
236
 
        struct lxc_list *networks = &lxc_conf->networks;
237
 
        struct lxc_network *network;
238
 
        struct lxc_netdev *netdev;
239
 
 
240
 
        if (lxc_list_empty(networks)) {
241
 
                ERROR("network is not created for %s", value);
242
 
                return -1;
243
 
        }
244
 
 
245
 
        network = lxc_list_first_elem(networks);
246
 
        if (!network) {
247
 
                ERROR("no network defined for %s", value);
248
 
                return -1;
249
 
        }
250
 
 
251
 
        netdev = lxc_list_first_elem(&network->netdev);
 
196
 
 
197
        return 0;
 
198
}
 
199
 
 
200
static int config_network_link(const char *key, char *value,
 
201
                               struct lxc_conf *lxc_conf)
 
202
{
 
203
        struct lxc_netdev *netdev;
 
204
 
 
205
        netdev = network_netdev(key, value, &lxc_conf->network);
 
206
        if (!netdev)
 
207
                return -1;
 
208
 
 
209
        return network_ifname(&netdev->link, value);
 
210
}
 
211
 
 
212
static int config_network_name(const char *key, char *value,
 
213
                               struct lxc_conf *lxc_conf)
 
214
{
 
215
        struct lxc_netdev *netdev;
 
216
 
 
217
        netdev = network_netdev(key, value, &lxc_conf->network);
 
218
        if (!netdev)
 
219
                return -1;
 
220
 
 
221
        return network_ifname(&netdev->name, value);
 
222
}
 
223
 
 
224
static int config_network_hwaddr(const char *key, char *value,
 
225
                                 struct lxc_conf *lxc_conf)
 
226
{
 
227
        struct lxc_netdev *netdev;
 
228
 
 
229
        netdev = network_netdev(key, value, &lxc_conf->network);
 
230
        if (!netdev)
 
231
                return -1;
 
232
 
252
233
        netdev->hwaddr = strdup(value);
 
234
        if (!netdev->hwaddr) {
 
235
                SYSERROR("failed to dup string '%s'", value);
 
236
                return -1;
 
237
        }
 
238
 
253
239
        return 0;
254
240
}
255
241
 
256
 
static int config_network_mtu(const char *key, char *value, struct lxc_conf *lxc_conf)
 
242
static int config_network_mtu(const char *key, char *value,
 
243
                              struct lxc_conf *lxc_conf)
257
244
{
258
 
        struct lxc_list *networks = &lxc_conf->networks;
259
 
        struct lxc_network *network;
260
245
        struct lxc_netdev *netdev;
261
246
 
262
 
        if (lxc_list_empty(networks)) {
263
 
                ERROR("network is not created for %s", value);
264
 
                return -1;
265
 
        }
266
 
 
267
 
        network = lxc_list_first_elem(networks);
268
 
        if (!network) {
269
 
                ERROR("no network defined for %s", value);
270
 
                return -1;
271
 
        }
272
 
 
273
 
        netdev = lxc_list_first_elem(&network->netdev);
 
247
        netdev = network_netdev(key, value, &lxc_conf->network);
 
248
        if (!netdev)
 
249
                return -1;
 
250
 
274
251
        netdev->mtu = strdup(value);
 
252
        if (!netdev->mtu) {
 
253
                SYSERROR("failed to dup string '%s'", value);
 
254
                return -1;
 
255
        }
 
256
 
275
257
        return 0;
276
258
}
277
259
 
278
 
static int config_network_ipv4(const char *key, char *value, struct lxc_conf *lxc_conf)
 
260
static int config_network_ipv4(const char *key, char *value,
 
261
                               struct lxc_conf *lxc_conf)
279
262
{
280
 
        struct lxc_list *networks = &lxc_conf->networks;
281
 
        struct lxc_network *network;
 
263
        struct lxc_netdev *netdev;
282
264
        struct lxc_inetdev *inetdev;
283
 
        struct lxc_netdev *netdev;
284
265
        struct lxc_list *list;
285
266
        char *cursor, *slash, *addr = NULL, *bcast = NULL, *prefix = NULL;
286
267
 
287
 
        if (lxc_list_empty(networks)) {
288
 
                ERROR("network is not created for '%s'", value);
289
 
                return -1;
290
 
        }
291
 
 
292
 
        network = lxc_list_first_elem(networks);
293
 
        if (!network) {
294
 
                ERROR("no network defined for '%s'", value);
295
 
                return -1;
296
 
        }
297
 
 
298
 
        netdev = lxc_list_first_elem(&network->netdev);
299
 
        if (!netdev) {
300
 
                ERROR("no netdev defined for '%s'", value);
301
 
        }
 
268
        netdev = network_netdev(key, value, &lxc_conf->network);
 
269
        if (!netdev)
 
270
                return -1;
302
271
 
303
272
        inetdev = malloc(sizeof(*inetdev));
304
273
        if (!inetdev) {
346
315
                        return -1;
347
316
                }
348
317
 
349
 
        if (prefix)
350
 
                inetdev->prefix = atoi(prefix);
 
318
        /* no prefix specified, determine it from the network class */
 
319
        inetdev->prefix = prefix ? atoi(prefix) :
 
320
                config_ip_prefix(&inetdev->addr);
 
321
 
351
322
 
352
323
        lxc_list_add(&netdev->ipv4, list);
353
324
 
356
327
 
357
328
static int config_network_ipv6(const char *key, char *value, struct lxc_conf *lxc_conf)
358
329
{
359
 
        struct lxc_list *networks = &lxc_conf->networks;
360
 
        struct lxc_network *network;
361
330
        struct lxc_netdev *netdev;
362
331
        struct lxc_inet6dev *inet6dev;
363
332
        struct lxc_list *list;
364
333
        char *slash;
365
334
        char *netmask;
366
335
 
367
 
        if (lxc_list_empty(networks)) {
368
 
                ERROR("network is not created for %s", value);
369
 
                return -1;
370
 
        }
371
 
 
372
 
        network = lxc_list_first_elem(networks);
373
 
        if (!network) {
374
 
                ERROR("no network defined for %s", value);
375
 
                return -1;
376
 
        }
 
336
        netdev = network_netdev(key, value, &lxc_conf->network);
 
337
        if (!netdev)
 
338
                return -1;
377
339
 
378
340
        inet6dev = malloc(sizeof(*inet6dev));
379
341
        if (!inet6dev) {
391
353
        lxc_list_init(list);
392
354
        list->elem = inet6dev;
393
355
 
 
356
        inet6dev->prefix = 64;
394
357
        slash = strstr(value, "/");
395
358
        if (slash) {
396
359
                *slash = '\0';
403
366
                return -1;
404
367
        }
405
368
 
406
 
 
407
 
        netdev = lxc_list_first_elem(&network->netdev);
408
369
        lxc_list_add(&netdev->ipv6, list);
409
370
 
410
371
        return 0;
467
428
        return 0;
468
429
}
469
430
 
470
 
static int config_mount(const char *key, char *value, struct lxc_conf *lxc_conf)
 
431
static int config_fstab(const char *key, char *value, struct lxc_conf *lxc_conf)
471
432
{
472
433
        if (strlen(value) >= MAXPATHLEN) {
473
434
                ERROR("%s path is too long", value);
483
444
        return 0;
484
445
}
485
446
 
 
447
static int config_mount(const char *key, char *value, struct lxc_conf *lxc_conf)
 
448
{
 
449
        char *fstab_token = "lxc.mount";
 
450
        char *token = "lxc.mount.entry";
 
451
        char *subkey;
 
452
        char *mntelem;
 
453
        struct lxc_list *mntlist;
 
454
 
 
455
        subkey = strstr(key, token);
 
456
 
 
457
        if (!subkey) {
 
458
                subkey = strstr(key, fstab_token);
 
459
 
 
460
                if (!subkey)
 
461
                        return -1;
 
462
 
 
463
                return config_fstab(key, value, lxc_conf);
 
464
        }
 
465
 
 
466
        if (!strlen(subkey))
 
467
                return -1;
 
468
 
 
469
        mntlist = malloc(sizeof(*mntlist));
 
470
        if (!mntlist)
 
471
                return -1;
 
472
 
 
473
        mntelem = strdup(value);
 
474
        mntlist->elem = mntelem;
 
475
 
 
476
        lxc_list_add_tail(&lxc_conf->mount_list, mntlist);
 
477
 
 
478
        return 0;
 
479
}
 
480
 
486
481
static int config_rootfs(const char *key, char *value, struct lxc_conf *lxc_conf)
487
482
{
488
483
        if (strlen(value) >= MAXPATHLEN) {