*
* DHCP client library with GLib integration
*
- * Copyright (C) 2009-2011 Intel Corporation. All rights reserved.
+ * Copyright (C) 2009-2012 Intel Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
uint32_t server_ip;
uint32_t requested_ip;
char *assigned_ip;
+ time_t start;
uint32_t lease_seconds;
ListenMode listen_mode;
int listener_sockfd;
add_binary_option, packet);
}
+/*
+ * Return an RFC 951- and 2131-complaint BOOTP 'secs' value that
+ * represents the number of seconds elapsed from the start of
+ * attempting DHCP to satisfy some DHCP servers that allow for an
+ * "authoritative" reply before responding.
+ */
+static uint16_t dhcp_attempt_secs(GDHCPClient *dhcp_client)
+{
+ return htons(MIN(time(NULL) - dhcp_client->start, UINT16_MAX));
+}
+
static int send_discover(GDHCPClient *dhcp_client, uint32_t requested)
{
struct dhcp_packet packet;
init_packet(dhcp_client, &packet, DHCPDISCOVER);
packet.xid = dhcp_client->xid;
+ packet.secs = dhcp_attempt_secs(dhcp_client);
if (requested)
dhcp_add_simple_option(&packet, DHCP_REQUESTED_IP, requested);
init_packet(dhcp_client, &packet, DHCPREQUEST);
packet.xid = dhcp_client->xid;
+ packet.secs = dhcp_attempt_secs(dhcp_client);
dhcp_add_simple_option(&packet, DHCP_REQUESTED_IP,
dhcp_client->requested_ip);
get_interface_mac_address(index, &(*duid)[2 + 2 + 4]);
(*duid)[2] = 0;
(*duid)[3] = type;
- duid_time = time(0) - DUID_TIME_EPOCH;
+ duid_time = time(NULL) - DUID_TIME_EPOCH;
(*duid)[4] = duid_time >> 24;
(*duid)[5] = duid_time >> 16;
(*duid)[6] = duid_time >> 8;
dhcp_client->require_list = NULL;
dhcp_client->duid = NULL;
dhcp_client->duid_len = 0;
- dhcp_client->last_renew = dhcp_client->last_rebind = time(0);
+ dhcp_client->last_renew = dhcp_client->last_rebind = time(NULL);
dhcp_client->expire = 0;
*error = G_DHCP_CLIENT_ERROR_NONE;
int target_conflict;
memset(&arp, 0, sizeof(arp));
- bytes = 0;
bytes = read(dhcp_client->listener_sockfd, &arp, sizeof(arp));
if (bytes < 0)
return bytes;
dhcp_client->retry_times = retry_times;
dhcp_client->requested_ip = 0;
+ dhcp_client->state = INIT_SELECTING;
switch_listening_mode(dhcp_client, L2);
g_dhcp_client_start(dhcp_client, dhcp_client->last_address);
uint8_t *option;
char *str;
+ if (value == NULL || len < 4)
+ return NULL;
+
iaid = get_uint32(&value[0]);
if (dhcp_client->iaid != iaid)
return NULL;
if (addr_count > 0 && st == 0) {
/* We only support one address atm */
- char str[INET6_ADDRSTRLEN + 1];
+ char addr_str[INET6_ADDRSTRLEN + 1];
if (preferred > valid)
/* RFC 3315, 22.6 */
dhcp_client->T1 = T1;
dhcp_client->T2 = T2;
- inet_ntop(AF_INET6, &addr, str, INET6_ADDRSTRLEN);
+ inet_ntop(AF_INET6, &addr, addr_str, INET6_ADDRSTRLEN);
debug(dhcp_client, "count %d addr %s T1 %u T2 %u",
- addr_count, str, T1, T2);
+ addr_count, addr_str, T1, T2);
- list = g_list_append(list, g_strdup(str));
+ list = g_list_append(list, g_strdup(addr_str));
if (code == G_DHCPV6_IA_NA)
memcpy(&dhcp_client->ia_na, &addr,
char *str;
int i;
+ if (value == NULL)
+ return NULL;
+
switch (code) {
case G_DHCPV6_DNS_SERVERS: /* RFC 3646, chapter 3 */
case G_DHCPV6_SNTP_SERVERS: /* RFC 4075, chapter 4 */
re = dhcp_recv_l3_packet(&packet,
dhcp_client->listener_sockfd);
} else if (dhcp_client->listen_mode == L_ARP) {
- re = ipv4ll_recv_arp_packet(dhcp_client);
+ ipv4ll_recv_arp_packet(dhcp_client);
return TRUE;
}
else
return TRUE;
if (dhcp_client->type == G_DHCP_IPV6) {
+ if (packet6 == NULL)
+ return TRUE;
+
count = 0;
client_id = dhcpv6_get_option(packet6, pkt_len,
G_DHCPV6_CLIENTID, &option_len, &count);
} else
dhcp_client->status_code = 0;
- } else
+ } else {
message_type = dhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
+ if (message_type == NULL)
+ return TRUE;
+ }
if (message_type == NULL && client_id == NULL)
/* No message type / client id option, ignore package */
return re;
dhcp_client->xid = rand();
+ dhcp_client->start = time(NULL);
}
if (last_address == NULL) {
g_hash_table_remove_all(dhcp_client->send_value_hash);
}
-static uint8_t *alloc_dhcp_option(int code, const char *str, int extra)
+static uint8_t *alloc_dhcp_option(int code, const uint8_t *data, unsigned size)
{
uint8_t *storage;
- int len = strnlen(str, 255);
- storage = malloc(len + extra + OPT_DATA);
+ storage = g_try_malloc(size + OPT_DATA);
+ if (storage == NULL)
+ return NULL;
+
storage[OPT_CODE] = code;
- storage[OPT_LEN] = len + extra;
- memcpy(storage + extra + OPT_DATA, str, len);
+ storage[OPT_LEN] = size;
+ memcpy(&storage[OPT_DATA], data, size);
return storage;
}
+static uint8_t *alloc_dhcp_data_option(int code, const uint8_t *data, unsigned size)
+{
+ return alloc_dhcp_option(code, data, MIN(size, 255));
+}
+
+static uint8_t *alloc_dhcp_string_option(int code, const char *str)
+{
+ return alloc_dhcp_data_option(code, (const uint8_t *)str, strlen(str));
+}
+
+GDHCPClientError g_dhcp_client_set_id(GDHCPClient *dhcp_client)
+{
+ const unsigned maclen = 6;
+ const unsigned idlen = maclen + 1;
+ const uint8_t option_code = G_DHCP_CLIENT_ID;
+ uint8_t idbuf[idlen];
+ uint8_t *data_option;
+
+ idbuf[0] = ARPHRD_ETHER;
+
+ memcpy(&idbuf[1], dhcp_client->mac_address, maclen);
+
+ data_option = alloc_dhcp_data_option(option_code, idbuf, idlen);
+ if (data_option == NULL)
+ return G_DHCP_CLIENT_ERROR_NOMEM;
+
+ g_hash_table_insert(dhcp_client->send_value_hash,
+ GINT_TO_POINTER((int) option_code), data_option);
+
+ return G_DHCP_CLIENT_ERROR_NONE;
+}
+
/* Now only support send hostname */
GDHCPClientError g_dhcp_client_set_send(GDHCPClient *dhcp_client,
unsigned char option_code, const char *option_value)
uint8_t *binary_option;
if (option_code == G_DHCP_HOST_NAME && option_value != NULL) {
- binary_option = alloc_dhcp_option(option_code,
- option_value, 0);
+ binary_option = alloc_dhcp_string_option(option_code,
+ option_value);
+ if (binary_option == NULL)
+ return G_DHCP_CLIENT_ERROR_NOMEM;
g_hash_table_insert(dhcp_client->send_value_hash,
GINT_TO_POINTER((int) option_code), binary_option);
if (dhcp_client == NULL || dhcp_client->type == G_DHCP_IPV4)
return;
- dhcp_client->last_renew = time(0);
+ dhcp_client->last_renew = time(NULL);
}
void g_dhcpv6_client_reset_rebind(GDHCPClient *dhcp_client)
if (dhcp_client == NULL || dhcp_client->type == G_DHCP_IPV4)
return;
- dhcp_client->last_rebind = time(0);
+ dhcp_client->last_rebind = time(NULL);
}
void g_dhcpv6_client_set_expire(GDHCPClient *dhcp_client, uint32_t timeout)
if (dhcp_client == NULL || dhcp_client->type == G_DHCP_IPV4)
return;
- dhcp_client->expire = time(0) + timeout;
+ dhcp_client->expire = time(NULL) + timeout;
}
uint16_t g_dhcpv6_client_get_status(GDHCPClient *dhcp_client)
projects / platform / upstream / connman.git / blobdiff