opt = find_dhcp_option (bp, size, GRUB_NET_BOOTP_EXTENSIONS_PATH, &opt_len);
if (opt && opt_len)
grub_env_set_net_property (name, "extensionspath", (const char *) opt, opt_len);
-
+
opt = find_dhcp_option (bp, size, GRUB_NET_BOOTP_CLIENT_ID, &opt_len);
if (opt && opt_len)
grub_env_set_net_property (name, "clientid", (const char *) opt, opt_len);
return grub_errno;
}
ifaces[j].address.type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV;
- grub_memcpy (&ifaces[j].hwaddress, &card->default_address,
+ grub_memcpy (&ifaces[j].hwaddress, &card->default_address,
sizeof (ifaces[j].hwaddress));
ifaces[j].dhcp_tmo = ifaces[j].dhcp_tmo_left = 1;
j++;
}
if (readable_ptr && grub_memcmp (ptr + 1, readable_ptr, *ptr) != 0)
return 0;
- if (grub_memchr (ptr + 1, 0, *ptr)
+ if (grub_memchr (ptr + 1, 0, *ptr)
|| grub_memchr (ptr + 1, '.', *ptr))
return 0;
if (readable_ptr)
DNS_CLASS_AAAA = 28
};
-static grub_err_t
+static grub_err_t
recv_hook (grub_net_udp_socket_t sock __attribute__ ((unused)),
struct grub_net_buff *nb,
void *data_)
grub_netbuff_free (nb);
return GRUB_ERR_NONE;
}
-
+
if (head->id != data->id)
{
grub_netbuff_free (nb);
grub_netbuff_free (nb);
for (j = 0; j < send_servers; j++)
grub_net_udp_close (sockets[j]);
-
+
grub_free (sockets);
if (*data.naddresses)
if (data.dns_err)
return grub_error (GRUB_ERR_NET_NO_DOMAIN,
N_("no DNS record found"));
-
+
if (err)
{
grub_errno = err;
{
struct grub_net_card *card, *next;
- FOR_NET_CARDS_SAFE (card, next)
+ FOR_NET_CARDS_SAFE (card, next)
if (card->driver == &efidriver)
grub_net_card_unregister (card);
}
GRUB_MOD_LICENSE ("GPLv3+");
-static grub_err_t
+static grub_err_t
send_card_buffer (struct grub_net_card *dev __attribute__ ((unused)),
struct grub_net_buff *pack);
static struct grub_net_buff *
get_card_packet (struct grub_net_card *dev __attribute__ ((unused)));
-static struct grub_net_card_driver emudriver =
+static struct grub_net_card_driver emudriver =
{
.name = "emu",
.send = send_card_buffer,
.recv = get_card_packet
};
-static struct grub_net_card emucard =
+static struct grub_net_card emucard =
{
.name = "emu0",
.driver = &emudriver,
.flags = 0
};
-static grub_err_t
+static grub_err_t
send_card_buffer (struct grub_net_card *dev __attribute__ ((unused)),
struct grub_net_buff *pack)
{
return buf;
}
-static grub_err_t
+static grub_err_t
grub_pxe_send (struct grub_net_card *dev __attribute__ ((unused)),
struct grub_net_buff *pack)
{
if (ou->status)
return grub_error (GRUB_ERR_IO, "can't open UNDI");
return GRUB_ERR_NONE;
-}
+}
struct grub_net_card_driver grub_pxe_card_driver =
{
{
struct grub_net_card *card, *next;
- FOR_NET_CARDS_SAFE (card, next)
+ FOR_NET_CARDS_SAFE (card, next)
if (card->driver && grub_strcmp (card->driver->name, "ofnet") == 0)
grub_net_card_unregister (card);
grub_ieee1275_net_config = 0;
{
struct grub_net_card *card, *next;
- FOR_NET_CARDS_SAFE (card, next)
+ FOR_NET_CARDS_SAFE (card, next)
if (card->driver && grub_strcmp (card->driver->name, "ubnet") == 0)
grub_net_card_unregister (card);
}
struct snaphdr
{
- grub_uint8_t oui[3];
+ grub_uint8_t oui[3];
grub_uint16_t type;
} GRUB_PACKED;
return GRUB_ERR_NONE;
}
- return GRUB_ERR_NONE;
+ return GRUB_ERR_NONE;
}
static void
grub_net_tcp_close (data->sock, GRUB_NET_TCP_ABORT);
return grub_errno;
}
-
+
data->current_line = t;
grub_memcpy (data->current_line + data->current_line_len,
nb->data, ptr - (char *) nb->data);
{
grub_netbuff_free (nb);
return GRUB_ERR_NONE;
- }
+ }
err = grub_netbuff_pull (nb, ptr - (char *) nb->data);
if (err)
{
grub_strlen (file->device->net->server));
ptr = nb->tail;
- err = grub_netbuff_put (nb,
+ err = grub_netbuff_put (nb,
sizeof ("\r\nUser-Agent: " PACKAGE_STRING "\r\n")
- 1);
if (err)
return 0;
}
-static struct grub_net_app_protocol grub_http_protocol =
+static struct grub_net_app_protocol grub_http_protocol =
{
.name = "http",
.open = http_open,
if (ohdr->len == 0 || ptr + 8 * ohdr->len > nb->tail)
{
grub_netbuff_free (nb);
- return GRUB_ERR_NONE;
+ return GRUB_ERR_NONE;
}
if (ohdr->type == OPTION_SOURCE_LINK_LAYER_ADDRESS
&& ohdr->len == 1)
if (ohdr->len == 0 || ptr + 8 * ohdr->len > nb->tail)
{
grub_netbuff_free (nb);
- return GRUB_ERR_NONE;
+ return GRUB_ERR_NONE;
}
if (ohdr->type == OPTION_TARGET_LINK_LAYER_ADDRESS
&& ohdr->len == 1)
if (ohdr->len == 0 || ptr + 8 * ohdr->len > nb->tail)
{
grub_netbuff_free (nb);
- return GRUB_ERR_NONE;
+ return GRUB_ERR_NONE;
}
if (ohdr->type == OPTION_SOURCE_LINK_LAYER_ADDRESS
&& ohdr->len == 1)
grub_errno = GRUB_ERR_NONE;
continue;
}
- inf = grub_net_add_addr (name,
+ inf = grub_net_add_addr (name,
card, &addr,
&slaac->address, 0);
if (!route_inf)
multicast.ipv6[1] = (grub_be_to_cpu64_compile_time (0x01ff000000ULL)
| (proto_addr->ipv6[1]
& grub_be_to_cpu64_compile_time (0xffffff)));
-
+
err = grub_net_link_layer_resolve (inf, &multicast, &ll_multicast);
if (err)
return err;
ohdr = (struct option_header *) nb->data;
ohdr->type = OPTION_SOURCE_LINK_LAYER_ADDRESS;
ohdr->len = 1;
- err = grub_netbuff_push (nb, sizeof (*sol));
+ err = grub_netbuff_push (nb, sizeof (*sol));
if (err)
goto fail;
iph->service = 0;
iph->len = grub_cpu_to_be16 (len + sizeof (struct iphdr));
iph->ident = grub_cpu_to_be16 (id);
- iph->frags = grub_cpu_to_be16 (off | (((grub_ssize_t) len
+ iph->frags = grub_cpu_to_be16 (off | (((grub_ssize_t) len
== nb->tail - nb->data)
? 0 : MORE_FRAGMENTS));
iph->ttl = 0xff;
if (expected != chk)
{
grub_dprintf ("net", "Invalid UDP checksum. "
- "Expected %x, got %x\n",
+ "Expected %x, got %x\n",
grub_be_to_cpu16 (expected),
grub_be_to_cpu16 (chk));
grub_netbuff_free (nb);
}
bootp = (const struct grub_net_bootp_packet *) nb->data;
-
+
FOR_NET_NETWORK_LEVEL_INTERFACES (inf)
if (inf->card == card
&& inf->address.type == GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV
&& hwaddress->type == GRUB_NET_LINK_LEVEL_PROTOCOL_ETHERNET
&& hwaddress->mac[0] == 0x33 && hwaddress->mac[1] == 0x33
&& hwaddress->mac[2] == 0xff
- && hwaddress->mac[3] == ((grub_be_to_cpu64 (inf->address.ipv6[1])
+ && hwaddress->mac[3] == ((grub_be_to_cpu64 (inf->address.ipv6[1])
>> 16) & 0xff)
&& hwaddress->mac[4] == ((grub_be_to_cpu64 (inf->address.ipv6[1])
>> 8) & 0xff)
break;
}
}
-
+
if (!inf && !(dest->type == GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6
&& dest->ipv6[0] == grub_be_to_cpu64_compile_time (0xff02ULL
<< 48)
}
if (actual_size < expected_size)
{
- grub_dprintf ("net", "Cut IP packet actual: %" PRIuGRUB_SIZE
+ grub_dprintf ("net", "Cut IP packet actual: %" PRIuGRUB_SIZE
", expected %" PRIuGRUB_SIZE "\n", actual_size,
expected_size);
grub_netbuff_free (nb);
}
if (actual_size < expected_size)
{
- grub_dprintf ("net", "Cut IP packet actual: %" PRIuGRUB_SIZE
+ grub_dprintf ("net", "Cut IP packet actual: %" PRIuGRUB_SIZE
", expected %" PRIuGRUB_SIZE "\n", actual_size,
expected_size);
grub_netbuff_free (nb);
return NULL;
for (i = 0; i < LINK_LAYER_CACHE_SIZE; i++)
{
- if (card->link_layer_table[i].avail == 1
+ if (card->link_layer_table[i].avail == 1
&& grub_net_addr_cmp (&card->link_layer_table[i].nl_address,
proto) == 0)
return &card->link_layer_table[i];
*hw_addr = entry->ll_address;
return GRUB_ERR_NONE;
}
- return grub_error (GRUB_ERR_TIMEOUT,
+ return grub_error (GRUB_ERR_TIMEOUT,
N_("timeout: could not resolve hardware address"));
}
grub_net_network_level_interface_register (struct grub_net_network_level_interface *inter);
static struct grub_net_network_level_interface *
-grub_net_add_addr_real (char *name,
+grub_net_add_addr_real (char *name,
struct grub_net_card *card,
const grub_net_network_level_address_t *addr,
const grub_net_link_level_address_t *hwaddress,
}
struct grub_net_network_level_interface *
-grub_net_add_addr (const char *name,
+grub_net_add_addr (const char *name,
struct grub_net_card *card,
const grub_net_network_level_address_t *addr,
const grub_net_link_level_address_t *hwaddress,
{
char *name_dup = grub_strdup (name);
struct grub_net_network_level_interface *ret;
-
+
if (!name_dup)
return NULL;
ret = grub_net_add_addr_real (name_dup, card, addr, hwaddress, flags);
mask[0] = 0xffffffffffffffffULL << (64 - net->ipv6.masksize);
mask[1] = 0;
}
- else
+ else
{
mask[0] = 0xffffffffffffffffULL;
mask[1] = 0xffffffffffffffffULL << (128 - net->ipv6.masksize);
grub_free (inter->name);
grub_free (inter);
- return GRUB_ERR_NONE;
+ return GRUB_ERR_NONE;
}
void
{
grub_snprintf (ptr, 6, "%" PRIxGRUB_UINT64_T ":",
(n >> (48 - 16 * i)) & 0xffff);
- ptr += grub_strlen (ptr);
+ ptr += grub_strlen (ptr);
}
n = grub_be_to_cpu64 (target->ipv6[1]);
for (i = 0; i < 3; i++)
{
grub_snprintf (ptr, 6, "%" PRIxGRUB_UINT64_T ":",
(n >> (48 - 16 * i)) & 0xffff);
- ptr += grub_strlen (ptr);
+ ptr += grub_strlen (ptr);
}
grub_snprintf (ptr, 5, "%" PRIxGRUB_UINT64_T, n & 0xffff);
return;
return;
for (ptr = name; *ptr; ptr++)
if (*ptr == ':')
- *ptr = '_';
+ *ptr = '_';
grub_env_set (name, buf);
grub_register_variable_hook (name, 0, hwaddr_set_env);
grub_env_export (name);
return;
for (ptr = name; *ptr; ptr++)
if (*ptr == ':')
- *ptr = '_';
+ *ptr = '_';
grub_env_set (name, buf);
grub_register_variable_hook (name, 0, addr_set_env);
grub_env_export (name);
if (argc != 3)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("three arguments expected"));
-
+
FOR_NET_CARDS (card)
if (grub_strcmp (card->name, args[1]) == 0)
break;
if (card == NULL)
- return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("card not found"));
+ return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("card not found"));
err = grub_net_resolve_address (args[2], &addr);
if (err)
if (argc != 1)
return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
-
+
for (prev = &grub_net_routes, route = *prev; route; prev = &((*prev)->next),
route = *prev)
if (grub_strcmp (route->name, args[0]) == 0)
N_("three arguments expected"));
grub_net_resolve_net_address (args[1], &target);
-
+
if (grub_strcmp (args[2], "gw") == 0 && argc >= 4)
{
grub_err_t err;
if (route->is_gateway)
{
grub_printf ("gw ");
- print_address (&route->gw);
+ print_address (&route->gw);
}
else
- grub_printf ("%s", route->interface->name);
+ grub_printf ("%s", route->interface->name);
grub_printf ("\n");
}
return GRUB_ERR_NONE;
grub_error (GRUB_ERR_NET_BAD_ADDRESS,
N_("no server is specified"));
return NULL;
- }
+ }
for (try = 0; try < 2; try++)
{
while (received < 100)
{
/* Maybe should be better have a fixed number of packets for each card
- and just mark them as used and not used. */
+ and just mark them as used and not used. */
struct grub_net_buff *nb;
if (received > 10 && stop_condition && *stop_condition)
return ret;
}
-static grub_err_t
+static grub_err_t
grub_net_seek_real (struct grub_file *file, grub_off_t offset)
{
if (offset == file->device->net->offset)
grub_net_fini_hw (int noreturn __attribute__ ((unused)))
{
struct grub_net_card *card;
- FOR_NET_CARDS (card)
+ FOR_NET_CARDS (card)
if (card->opened)
{
if (card->driver->close)
if (unack->last_try > limit_time)
continue;
-
+
if (unack->try_count > TCP_RETRANSMISSION_COUNT)
{
error (sock);
grub_error (GRUB_ERR_BUG, "not an IP address");
return NULL;
}
-
+
err = grub_net_route_address (addr, &gateway, &inf);
if (err)
return NULL;
socket = grub_zalloc (sizeof (*socket));
if (socket == NULL)
- return NULL;
+ return NULL;
socket->out_port = out_port;
socket->inf = inf;
{
int j;
nb->data = nbd;
- err = grub_net_send_ip_packet (socket->inf, &(socket->out_nla),
+ err = grub_net_send_ip_packet (socket->inf, &(socket->out_nla),
&(socket->ll_target_addr), nb,
GRUB_NET_IP_TCP);
if (err)
grub_netbuff_free (nb);
return NULL;
}
- for (j = 0; (j < TCP_SYN_RETRANSMISSION_TIMEOUT / 50
+ for (j = 0; (j < TCP_SYN_RETRANSMISSION_TIMEOUT / 50
&& !socket->established); j++)
grub_net_poll_cards (50, &socket->established);
if (socket->established)
if (sock->fin_hook && just_closed)
sock->fin_hook (sock, sock->hook_data);
}
-
+
return GRUB_ERR_NONE;
}
if (grub_be_to_cpu16 (tcph->flags) & TCP_SYN)
sock = grub_zalloc (sizeof (*sock));
if (sock == NULL)
return grub_errno;
-
+
sock->out_port = grub_be_to_cpu16 (tcph->src);
sock->in_port = grub_be_to_cpu16 (tcph->dst);
sock->inf = inf;
{
case TFTP_OACK:
data->block_size = TFTP_DEFAULTSIZE_PACKET;
- data->have_oack = 1;
+ data->have_oack = 1;
for (ptr = nb->data + sizeof (tftph->opcode); ptr < nb->tail;)
{
if (grub_memcmp (ptr, "tsize\0", sizeof ("tsize\0") - 1) == 0)
return ack (data, data->block);
}
-static struct grub_net_app_protocol grub_tftp_protocol =
+static struct grub_net_app_protocol grub_tftp_protocol =
{
.name = "tftp",
.open = tftp_open,
grub_error (GRUB_ERR_BUG, "not an IP address");
return NULL;
}
-
+
err = grub_net_route_address (addr, &gateway, &inf);
if (err)
return NULL;
socket = grub_zalloc (sizeof (*socket));
if (socket == NULL)
- return NULL;
+ return NULL;
socket->out_port = out_port;
socket->inf = inf;
projects / thirdparty / grub.git / commitdiff
