← Back to branch summary

~serge-hallyn/ubuntu/quantal/lxc/lxc-fixapi

« back to all changes in this revision

Viewing changes to src/lxc/network.c

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2011-07-07 13:53:52 UTC
  • mfrom: (1.2.7 upstream)
  • mto: (3.1.15 sid)
  • mto: This revision was merged to the branch mainline in revision 20.
  • Revision ID: james.westby@ubuntu.com-20110707135352-2e27007vciicu4gf
Tags: upstream-0.7.4.2
Import upstream version 0.7.4.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lxc/network.c
89
89
        struct ifaddrmsg ifa;
90
90
};
91
91
 
92
 
int lxc_device_move(int ifindex, pid_t pid)
 
92
int lxc_netdev_move_by_index(int ifindex, pid_t pid)
93
93
{
94
94
        struct nl_handler nlh;
95
95
        struct nlmsg *nlmsg = NULL;
122
122
        return err;
123
123
}
124
124
 
125
 
int lxc_device_delete(const char *name)
126
 
{
127
 
        struct nl_handler nlh;
128
 
        struct nlmsg *nlmsg = NULL, *answer = NULL;
129
 
        struct link_req *link_req;
130
 
        int index, len, err;
131
 
 
132
 
        err = netlink_open(&nlh, NETLINK_ROUTE);
133
 
        if (err)
134
 
                return err;
135
 
 
136
 
        err = -EINVAL;
137
 
        len = strlen(name);
138
 
        if (len == 1 || len > IFNAMSIZ)
139
 
                goto out;
140
 
 
141
 
        err = -ENOMEM;
142
 
        nlmsg = nlmsg_alloc(NLMSG_GOOD_SIZE);
143
 
        if (!nlmsg)
144
 
                goto out;
145
 
 
146
 
        answer = nlmsg_alloc(NLMSG_GOOD_SIZE);
147
 
        if (!answer)
148
 
                goto out;
149
 
 
150
 
        err = -EINVAL;
151
 
        index = if_nametoindex(name);
152
 
        if (!index)
153
 
                goto out;
154
 
 
155
 
        link_req = (struct link_req *)nlmsg;
156
 
        link_req->ifinfomsg.ifi_family = AF_UNSPEC;
157
 
        link_req->ifinfomsg.ifi_index = index;
158
 
        nlmsg->nlmsghdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
159
 
        nlmsg->nlmsghdr.nlmsg_flags = NLM_F_ACK|NLM_F_REQUEST;
160
 
        nlmsg->nlmsghdr.nlmsg_type = RTM_DELLINK;
161
 
 
162
 
        if (nla_put_string(nlmsg, IFLA_IFNAME, name))
163
 
                goto out;
164
 
 
165
 
        err = netlink_transaction(&nlh, nlmsg, answer);
166
 
out:
167
 
        netlink_close(&nlh);
168
 
        nlmsg_free(answer);
169
 
        nlmsg_free(nlmsg);
170
 
        return err;
171
 
}
172
 
 
173
 
int lxc_device_delete_index(int ifindex)
 
125
int lxc_netdev_delete_by_index(int ifindex)
174
126
{
175
127
        struct nl_handler nlh;
176
128
        struct nlmsg *nlmsg = NULL, *answer = NULL;
205
157
        return err;
206
158
}
207
159
 
208
 
static int device_set_flag(const char *name, int flag)
 
160
int lxc_netdev_delete_by_name(const char *name)
 
161
{
 
162
        int index;
 
163
 
 
164
        index = if_nametoindex(name);
 
165
        if (!index)
 
166
                return -EINVAL;
 
167
 
 
168
        return lxc_netdev_delete_by_index(index);
 
169
}
 
170
 
 
171
int lxc_netdev_rename_by_index(int ifindex, const char *newname)
 
172
{
 
173
        struct nl_handler nlh;
 
174
        struct nlmsg *nlmsg = NULL, *answer = NULL;
 
175
        struct link_req *link_req;
 
176
        int len, err;
 
177
 
 
178
        err = netlink_open(&nlh, NETLINK_ROUTE);
 
179
        if (err)
 
180
                return err;
 
181
 
 
182
        len = strlen(newname);
 
183
        if (len == 1 || len > IFNAMSIZ)
 
184
                goto out;
 
185
 
 
186
        err = -ENOMEM;
 
187
        nlmsg = nlmsg_alloc(NLMSG_GOOD_SIZE);
 
188
        if (!nlmsg)
 
189
                goto out;
 
190
 
 
191
        answer = nlmsg_alloc(NLMSG_GOOD_SIZE);
 
192
        if (!answer)
 
193
                goto out;
 
194
 
 
195
        link_req = (struct link_req *)nlmsg;
 
196
        link_req->ifinfomsg.ifi_family = AF_UNSPEC;
 
197
        link_req->ifinfomsg.ifi_index = ifindex;
 
198
        nlmsg->nlmsghdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
 
199
        nlmsg->nlmsghdr.nlmsg_flags = NLM_F_ACK|NLM_F_REQUEST;
 
200
        nlmsg->nlmsghdr.nlmsg_type = RTM_NEWLINK;
 
201
 
 
202
        if (nla_put_string(nlmsg, IFLA_IFNAME, newname))
 
203
                goto out;
 
204
 
 
205
        err = netlink_transaction(&nlh, nlmsg, answer);
 
206
out:
 
207
        netlink_close(&nlh);
 
208
        nlmsg_free(answer);
 
209
        nlmsg_free(nlmsg);
 
210
        return err;
 
211
}
 
212
 
 
213
int lxc_netdev_rename_by_name(const char *oldname, const char *newname)
 
214
{
 
215
        int len, index;
 
216
 
 
217
        len = strlen(oldname);
 
218
        if (len == 1 || len > IFNAMSIZ)
 
219
                return -EINVAL;
 
220
 
 
221
        index = if_nametoindex(oldname);
 
222
        if (!index)
 
223
                return -EINVAL;
 
224
 
 
225
        return lxc_netdev_rename_by_index(index, newname);
 
226
}
 
227
 
 
228
static int netdev_set_flag(const char *name, int flag)
209
229
{
210
230
        struct nl_handler nlh;
211
231
        struct nlmsg *nlmsg = NULL, *answer = NULL;
252
272
        return err;
253
273
}
254
274
 
255
 
int lxc_device_set_mtu(const char *name, int mtu)
 
275
int lxc_netdev_set_mtu(const char *name, int mtu)
256
276
{
257
277
        struct nl_handler nlh;
258
278
        struct nlmsg *nlmsg = NULL, *answer = NULL;
300
320
        return err;
301
321
}
302
322
 
303
 
int lxc_device_up(const char *name)
304
 
{
305
 
        return device_set_flag(name, IFF_UP);
306
 
}
307
 
 
308
 
int lxc_device_down(const char *name)
309
 
{
310
 
        return device_set_flag(name, 0);
311
 
}
312
 
 
313
 
int lxc_device_rename(const char *oldname, const char *newname)
314
 
{
315
 
        struct nl_handler nlh;
316
 
        struct nlmsg *nlmsg = NULL, *answer = NULL;
317
 
        struct link_req *link_req;
318
 
        int index, len, err;
319
 
 
320
 
        err = netlink_open(&nlh, NETLINK_ROUTE);
321
 
        if (err)
322
 
                return err;
323
 
 
324
 
        err = -EINVAL;
325
 
        len = strlen(oldname);
326
 
        if (len == 1 || len > IFNAMSIZ)
327
 
                goto out;
328
 
 
329
 
        len = strlen(newname);
330
 
        if (len == 1 || len > IFNAMSIZ)
331
 
                goto out;
332
 
 
333
 
        err = -ENOMEM;
334
 
        nlmsg = nlmsg_alloc(NLMSG_GOOD_SIZE);
335
 
        if (!nlmsg)
336
 
                goto out;
337
 
 
338
 
        answer = nlmsg_alloc(NLMSG_GOOD_SIZE);
339
 
        if (!answer)
340
 
                goto out;
341
 
 
342
 
        err = -EINVAL;
343
 
        index = if_nametoindex(oldname);
344
 
        if (!index)
345
 
                goto out;
346
 
 
347
 
        link_req = (struct link_req *)nlmsg;
348
 
        link_req->ifinfomsg.ifi_family = AF_UNSPEC;
349
 
        link_req->ifinfomsg.ifi_index = index;
350
 
        nlmsg->nlmsghdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
351
 
        nlmsg->nlmsghdr.nlmsg_flags = NLM_F_ACK|NLM_F_REQUEST;
352
 
        nlmsg->nlmsghdr.nlmsg_type = RTM_NEWLINK;
353
 
 
354
 
        if (nla_put_string(nlmsg, IFLA_IFNAME, newname))
355
 
                goto out;
356
 
 
357
 
        err = netlink_transaction(&nlh, nlmsg, answer);
358
 
out:
359
 
        netlink_close(&nlh);
360
 
        nlmsg_free(answer);
361
 
        nlmsg_free(nlmsg);
362
 
        return err;
 
323
int lxc_netdev_up(const char *name)
 
324
{
 
325
        return netdev_set_flag(name, IFF_UP);
 
326
}
 
327
 
 
328
int lxc_netdev_down(const char *name)
 
329
{
 
330
        return netdev_set_flag(name, 0);
363
331
}
364
332
 
365
333
int lxc_veth_create(const char *name1, const char *name2)
775
743
 
776
744
/*
777
745
 * There is a lxc_bridge_attach, but no need of a bridge detach
778
 
 * as automatically done by kernel when device deleted.
 
746
 * as automatically done by kernel when a netdev is deleted.
779
747
 */
780
748
int lxc_bridge_attach(const char *bridge, const char *ifname)
781
749
{