#include <sys/types.h>
#include <time.h>
#include <unistd.h>
-#include "buffer.h"
#include "csum.h"
#include "dhcp.h"
#include "dynamic-string.h"
#include "flow.h"
#include "netdev.h"
-#include "ofp-print.h"
+#include "ofpbuf.h"
#include "poll-loop.h"
#include "sat-math.h"
#include "timeval.h"
#undef DHCLIENT_STATE
};
+static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
+
static const char *
state_name(enum dhclient_state state)
{
return 0;
}
+/* Destroys 'cli' and frees all related resources. */
+void
+dhclient_destroy(struct dhclient *cli)
+{
+ if (cli) {
+ dhcp_msg_uninit(cli->binding);
+ free(cli->binding);
+ netdev_close(cli->netdev);
+ ds_destroy(&cli->s);
+ free(cli);
+ }
+}
+
+/* Returns the network device in use by 'cli'. The caller must not destroy
+ * the returned device. */
+struct netdev *
+dhclient_get_netdev(struct dhclient *cli)
+{
+ return cli->netdev;
+}
+
/* Forces 'cli' into a (re)initialization state, in which no address is bound
* but the client is advertising to obtain one. If 'requested_ip' is nonzero,
* then the client will attempt to re-bind to that IP address; otherwise, it
{
while (do_receive_msg(cli, msg)) {
if (msg->type < 0 || msg->type > 31 || !((1u << msg->type) & msgs)) {
- VLOG_DBG("received unexpected %s in %s state: %s",
- dhcp_type_name(msg->type), state_name(cli->state),
- dhcp_msg_to_string(msg, false, &cli->s));
+ VLOG_DBG_RL(&rl, "received unexpected %s in %s state: %s",
+ dhcp_type_name(msg->type), state_name(cli->state),
+ dhcp_msg_to_string(msg, false, &cli->s));
} else if (msg->xid != cli->xid) {
- VLOG_DBG("ignoring %s with xid != %08"PRIx32" in %s state: %s",
- dhcp_type_name(msg->type), msg->xid,
- state_name(cli->state),
- dhcp_msg_to_string(msg, false, &cli->s));
+ VLOG_DBG_RL(&rl,
+ "ignoring %s with xid != %08"PRIx32" in %s state: %s",
+ dhcp_type_name(msg->type), msg->xid,
+ state_name(cli->state),
+ dhcp_msg_to_string(msg, false, &cli->s));
} else {
return true;
}
{
uint32_t lease, netmask;
if (!dhcp_msg_get_secs(msg, DHCP_CODE_LEASE_TIME, 0, &lease)) {
- VLOG_WARN("%s lacks lease time: %s", dhcp_type_name(msg->type),
- dhcp_msg_to_string(msg, false, &cli->s));
+ VLOG_WARN_RL(&rl, "%s lacks lease time: %s", dhcp_type_name(msg->type),
+ dhcp_msg_to_string(msg, false, &cli->s));
} else if (!dhcp_msg_get_ip(msg, DHCP_CODE_SUBNET_MASK, 0, &netmask)) {
- VLOG_WARN("%s lacks netmask: %s", dhcp_type_name(msg->type),
- dhcp_msg_to_string(msg, false, &cli->s));
+ VLOG_WARN_RL(&rl, "%s lacks netmask: %s", dhcp_type_name(msg->type),
+ dhcp_msg_to_string(msg, false, &cli->s));
} else if (lease < MIN_ACCEPTABLE_LEASE) {
- VLOG_WARN("Ignoring %s with %"PRIu32"-second lease time: %s",
- dhcp_type_name(msg->type), lease,
- dhcp_msg_to_string(msg, false, &cli->s));
+ VLOG_WARN_RL(&rl, "Ignoring %s with %"PRIu32"-second lease time: %s",
+ dhcp_type_name(msg->type), lease,
+ dhcp_msg_to_string(msg, false, &cli->s));
} else if (cli->validate_offer && !cli->validate_offer(msg, cli->aux)) {
- VLOG_DBG("client validation hook refused offer: %s",
- dhcp_msg_to_string(msg, false, &cli->s));
+ VLOG_DBG_RL(&rl, "client validation hook refused offer: %s",
+ dhcp_msg_to_string(msg, false, &cli->s));
} else {
return true;
}
}
if (!dhcp_msg_get_ip(&msg, DHCP_CODE_SERVER_IDENTIFIER,
0, &cli->server_ip)) {
- VLOG_WARN("DHCPOFFER lacks server identifier: %s",
- dhcp_msg_to_string(&msg, false, &cli->s));
+ VLOG_WARN_RL(&rl, "DHCPOFFER lacks server identifier: %s",
+ dhcp_msg_to_string(&msg, false, &cli->s));
continue;
}
- VLOG_DBG("accepting DHCPOFFER: %s",
- dhcp_msg_to_string(&msg, false, &cli->s));
+ VLOG_DBG_RL(&rl, "accepting DHCPOFFER: %s",
+ dhcp_msg_to_string(&msg, false, &cli->s));
cli->ipaddr = msg.yiaddr;
state_transition(cli, S_REQUESTING);
break;
static bool
do_receive_msg(struct dhclient *cli, struct dhcp_msg *msg)
{
- struct buffer b;
+ struct ofpbuf b;
- buffer_init(&b, netdev_get_mtu(cli->netdev) + VLAN_ETH_HEADER_LEN);
+ ofpbuf_init(&b, netdev_get_mtu(cli->netdev) + VLAN_ETH_HEADER_LEN);
for (; cli->received < 50; cli->received++) {
const struct ip_header *ip;
const struct dhcp_header *dhcp;
struct flow flow;
int error;
- buffer_clear(&b);
+ ofpbuf_clear(&b);
error = netdev_recv(cli->netdev, &b);
if (error) {
goto drained;
ip = b.l3;
if (IP_IS_FRAGMENT(ip->ip_frag_off)) {
/* We don't do reassembly. */
- VLOG_WARN("ignoring fragmented DHCP datagram");
+ VLOG_WARN_RL(&rl, "ignoring fragmented DHCP datagram");
continue;
}
dhcp = b.l7;
if (!dhcp) {
- VLOG_WARN("ignoring DHCP datagram with missing payload");
+ VLOG_WARN_RL(&rl, "ignoring DHCP datagram with missing payload");
continue;
}
- buffer_pull(&b, b.l7 - b.data);
+ ofpbuf_pull(&b, (char *)b.l7 - (char*)b.data);
error = dhcp_parse(msg, &b);
if (!error) {
- VLOG_DBG("received %s", dhcp_msg_to_string(msg, false, &cli->s));
- buffer_uninit(&b);
+ VLOG_DBG_RL(&rl, "received %s",
+ dhcp_msg_to_string(msg, false, &cli->s));
+ ofpbuf_uninit(&b);
return true;
}
}
netdev_drain(cli->netdev);
drained:
- buffer_uninit(&b);
+ ofpbuf_uninit(&b);
return false;
}
static void
do_send_msg(struct dhclient *cli, const struct dhcp_msg *msg)
{
- struct buffer b;
+ struct ofpbuf b;
struct eth_header eh;
struct ip_header nh;
struct udp_header th;
uint32_t udp_csum;
int error;
- buffer_init(&b, ETH_TOTAL_MAX);
- buffer_reserve(&b, ETH_HEADER_LEN + IP_HEADER_LEN + UDP_HEADER_LEN);
+ ofpbuf_init(&b, ETH_TOTAL_MAX);
+ ofpbuf_reserve(&b, ETH_HEADER_LEN + IP_HEADER_LEN + UDP_HEADER_LEN);
dhcp_assemble(msg, &b);
udp_csum = csum_continue(udp_csum, &th, sizeof th);
th.udp_csum = csum_finish(csum_continue(udp_csum, b.data, b.size));
- buffer_push(&b, &th, sizeof th);
- buffer_push(&b, &nh, sizeof nh);
- buffer_push(&b, &eh, sizeof eh);
+ ofpbuf_push(&b, &th, sizeof th);
+ ofpbuf_push(&b, &nh, sizeof nh);
+ ofpbuf_push(&b, &eh, sizeof eh);
/* Don't try to send the frame if it's too long for an Ethernet frame. We
* disregard the network device's actual MTU because we don't want the
VLOG_ERR("cannot send %zu-byte Ethernet frame", b.size);
}
- buffer_uninit(&b);
+ ofpbuf_uninit(&b);
}
static unsigned int
git://git.onelab.eu / sliver-openvswitch.git / blobdiff