← Back to branch summary

~ubuntu-branches/ubuntu/trusty/grub2/trusty-updates

« back to all changes in this revision

Viewing changes to grub-core/net/net.c

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2012-09-13 18:02:04 UTC
  • mfrom: (1.17.15 upstream)
  • mto: (17.6.27 experimental)
  • mto: This revision was merged to the branch mainline in revision 145.
  • Revision ID: package-import@ubuntu.com-20120913180204-mojnmocbimlom4im
Tags: upstream-2.00
Import upstream version 2.00

Show diffs side-by-side

added added

removed removed

Lines of Context:
grub-core/net/net.c
 
1
/*
 
2
 *  GRUB  --  GRand Unified Bootloader
 
3
 *  Copyright (C) 2010,2011  Free Software Foundation, Inc.
 
4
 *
 
5
 *  GRUB is free software: you can redistribute it and/or modify
 
6
 *  it under the terms of the GNU General Public License as published by
 
7
 *  the Free Software Foundation, either version 3 of the License, or
 
8
 *  (at your option) any later version.
 
9
 *
 
10
 *  GRUB is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 
17
 */
 
18
 
 
19
#include <grub/net.h>
 
20
#include <grub/net/netbuff.h>
 
21
#include <grub/time.h>
 
22
#include <grub/file.h>
 
23
#include <grub/i18n.h>
 
24
#include <grub/mm.h>
 
25
#include <grub/misc.h>
 
26
#include <grub/dl.h>
 
27
#include <grub/command.h>
 
28
#include <grub/env.h>
 
29
#include <grub/net/ethernet.h>
 
30
#include <grub/net/arp.h>
 
31
#include <grub/net/ip.h>
 
32
#include <grub/loader.h>
 
33
#include <grub/bufio.h>
 
34
#include <grub/kernel.h>
 
35
 
 
36
GRUB_MOD_LICENSE ("GPLv3+");
 
37
 
 
38
char *grub_net_default_server;
 
39
 
 
40
struct grub_net_route
 
41
{
 
42
  struct grub_net_route *next;
 
43
  struct grub_net_route **prev;
 
44
  grub_net_network_level_netaddress_t target;
 
45
  char *name;
 
46
  struct grub_net_network_level_protocol *prot;
 
47
  int is_gateway;
 
48
  union
 
49
  {
 
50
    struct grub_net_network_level_interface *interface;
 
51
    grub_net_network_level_address_t gw;
 
52
  };
 
53
};
 
54
 
 
55
struct grub_net_route *grub_net_routes = NULL;
 
56
struct grub_net_network_level_interface *grub_net_network_level_interfaces = NULL;
 
57
struct grub_net_card *grub_net_cards = NULL;
 
58
struct grub_net_network_level_protocol *grub_net_network_level_protocols = NULL;
 
59
static struct grub_fs grub_net_fs;
 
60
 
 
61
struct grub_net_link_layer_entry {
 
62
  int avail;
 
63
  grub_net_network_level_address_t nl_address;
 
64
  grub_net_link_level_address_t ll_address;
 
65
};
 
66
 
 
67
#define LINK_LAYER_CACHE_SIZE 256
 
68
 
 
69
static struct grub_net_link_layer_entry *
 
70
link_layer_find_entry (const grub_net_network_level_address_t *proto,
 
71
                       const struct grub_net_card *card)
 
72
{
 
73
  unsigned i;
 
74
  if (!card->link_layer_table)
 
75
    return NULL;
 
76
  for (i = 0; i < LINK_LAYER_CACHE_SIZE; i++)
 
77
    {
 
78
      if (card->link_layer_table[i].avail == 1 
 
79
          && grub_net_addr_cmp (&card->link_layer_table[i].nl_address,
 
80
                                proto) == 0)
 
81
        return &card->link_layer_table[i];
 
82
    }
 
83
  return NULL;
 
84
}
 
85
 
 
86
void
 
87
grub_net_link_layer_add_address (struct grub_net_card *card,
 
88
                                 const grub_net_network_level_address_t *nl,
 
89
                                 const grub_net_link_level_address_t *ll,
 
90
                                 int override)
 
91
{
 
92
  struct grub_net_link_layer_entry *entry;
 
93
 
 
94
  /* Check if the sender is in the cache table.  */
 
95
  entry = link_layer_find_entry (nl, card);
 
96
  /* Update sender hardware address.  */
 
97
  if (entry && override)
 
98
    grub_memcpy (&entry->ll_address, ll, sizeof (entry->ll_address));
 
99
  if (entry)
 
100
    return;
 
101
 
 
102
  /* Add sender to cache table.  */
 
103
  if (card->link_layer_table == NULL)
 
104
    card->link_layer_table = grub_zalloc (LINK_LAYER_CACHE_SIZE
 
105
                                          * sizeof (card->link_layer_table[0]));
 
106
  entry = &(card->link_layer_table[card->new_ll_entry]);
 
107
  entry->avail = 1;
 
108
  grub_memcpy (&entry->ll_address, ll, sizeof (entry->ll_address));
 
109
  grub_memcpy (&entry->nl_address, nl, sizeof (entry->nl_address));
 
110
  card->new_ll_entry++;
 
111
  if (card->new_ll_entry == LINK_LAYER_CACHE_SIZE)
 
112
    card->new_ll_entry = 0;
 
113
}
 
114
 
 
115
int
 
116
grub_net_link_layer_resolve_check (struct grub_net_network_level_interface *inf,
 
117
                                   const grub_net_network_level_address_t *proto_addr)
 
118
{
 
119
  struct grub_net_link_layer_entry *entry;
 
120
 
 
121
  if (proto_addr->type == GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4
 
122
      && proto_addr->ipv4 == 0xffffffff)
 
123
    return 1;
 
124
  entry = link_layer_find_entry (proto_addr, inf->card);
 
125
  if (entry)
 
126
    return 1;
 
127
  return 0;
 
128
}
 
129
 
 
130
grub_err_t
 
131
grub_net_link_layer_resolve (struct grub_net_network_level_interface *inf,
 
132
                             const grub_net_network_level_address_t *proto_addr,
 
133
                             grub_net_link_level_address_t *hw_addr)
 
134
{
 
135
  struct grub_net_link_layer_entry *entry;
 
136
  grub_err_t err;
 
137
 
 
138
  if ((proto_addr->type == GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4
 
139
       && proto_addr->ipv4 == 0xffffffff)
 
140
      || proto_addr->type == GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV
 
141
      || (proto_addr->type == GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6
 
142
          && proto_addr->ipv6[0] == grub_be_to_cpu64_compile_time (0xff02ULL
 
143
                                                                   << 48)
 
144
          && proto_addr->ipv6[1] == (grub_be_to_cpu64_compile_time (1))))
 
145
    {
 
146
      hw_addr->type = GRUB_NET_LINK_LEVEL_PROTOCOL_ETHERNET;
 
147
      grub_memset (hw_addr->mac, -1, 6);
 
148
      return GRUB_ERR_NONE;
 
149
    }
 
150
 
 
151
  if (proto_addr->type == GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6
 
152
      && ((grub_be_to_cpu64 (proto_addr->ipv6[0]) >> 56) == 0xff))
 
153
    {
 
154
      hw_addr->type = GRUB_NET_LINK_LEVEL_PROTOCOL_ETHERNET;
 
155
      hw_addr->mac[0] = 0x33;
 
156
      hw_addr->mac[1] = 0x33;
 
157
      hw_addr->mac[2] = ((grub_be_to_cpu64 (proto_addr->ipv6[1]) >> 24) & 0xff);
 
158
      hw_addr->mac[3] = ((grub_be_to_cpu64 (proto_addr->ipv6[1]) >> 16) & 0xff);
 
159
      hw_addr->mac[4] = ((grub_be_to_cpu64 (proto_addr->ipv6[1]) >> 8) & 0xff);
 
160
      hw_addr->mac[5] = ((grub_be_to_cpu64 (proto_addr->ipv6[1]) >> 0) & 0xff);
 
161
      return GRUB_ERR_NONE;
 
162
    }
 
163
 
 
164
  /* Check cache table.  */
 
165
  entry = link_layer_find_entry (proto_addr, inf->card);
 
166
  if (entry)
 
167
    {
 
168
      *hw_addr = entry->ll_address;
 
169
      return GRUB_ERR_NONE;
 
170
    }
 
171
  switch (proto_addr->type)
 
172
    {
 
173
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4:
 
174
      err = grub_net_arp_send_request (inf, proto_addr);
 
175
      break;
 
176
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6:
 
177
      err = grub_net_icmp6_send_request (inf, proto_addr);
 
178
      break;
 
179
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV:
 
180
      return grub_error (GRUB_ERR_BUG, "shouldn't reach here");
 
181
    default:
 
182
      return grub_error (GRUB_ERR_BUG,
 
183
                         "unsupported address type %d", proto_addr->type);
 
184
    }
 
185
  if (err)
 
186
    return err;
 
187
  entry = link_layer_find_entry (proto_addr, inf->card);
 
188
  if (entry)
 
189
    {
 
190
      *hw_addr = entry->ll_address;
 
191
      return GRUB_ERR_NONE;
 
192
    }
 
193
  return grub_error (GRUB_ERR_TIMEOUT, 
 
194
                     N_("timeout: could not resolve hardware address"));
 
195
}
 
196
 
 
197
void
 
198
grub_net_card_unregister (struct grub_net_card *card)
 
199
{
 
200
  struct grub_net_network_level_interface *inf, *next;
 
201
  FOR_NET_NETWORK_LEVEL_INTERFACES_SAFE(inf, next)
 
202
    if (inf->card == card)
 
203
      grub_net_network_level_interface_unregister (inf);
 
204
  if (card->opened)
 
205
    {
 
206
      if (card->driver->close)
 
207
        card->driver->close (card);
 
208
      card->opened = 0;
 
209
    }
 
210
  grub_list_remove (GRUB_AS_LIST (card));
 
211
}
 
212
 
 
213
static struct grub_net_slaac_mac_list *
 
214
grub_net_ipv6_get_slaac (struct grub_net_card *card,
 
215
                         const grub_net_link_level_address_t *hwaddr)
 
216
{
 
217
  struct grub_net_slaac_mac_list *slaac;
 
218
  char *ptr;
 
219
 
 
220
  for (slaac = card->slaac_list; slaac; slaac = slaac->next)
 
221
    if (grub_net_hwaddr_cmp (&slaac->address, hwaddr) == 0)
 
222
      return slaac;
 
223
 
 
224
  slaac = grub_zalloc (sizeof (*slaac));
 
225
  if (!slaac)
 
226
    return NULL;
 
227
 
 
228
  slaac->name = grub_malloc (grub_strlen (card->name)
 
229
                             + GRUB_NET_MAX_STR_HWADDR_LEN
 
230
                             + sizeof (":slaac"));
 
231
  ptr = grub_stpcpy (slaac->name, card->name);
 
232
  if (grub_net_hwaddr_cmp (&card->default_address, hwaddr) != 0)
 
233
    {
 
234
      ptr = grub_stpcpy (ptr, ":");
 
235
      grub_net_hwaddr_to_str (hwaddr, ptr);
 
236
      ptr += grub_strlen (ptr);
 
237
    }
 
238
  ptr = grub_stpcpy (ptr, ":slaac");
 
239
 
 
240
  grub_memcpy (&slaac->address, hwaddr, sizeof (slaac->address));
 
241
  slaac->next = card->slaac_list;
 
242
  card->slaac_list = slaac;
 
243
  return slaac;
 
244
}
 
245
 
 
246
struct grub_net_network_level_interface *
 
247
grub_net_ipv6_get_link_local (struct grub_net_card *card,
 
248
                              const grub_net_link_level_address_t *hwaddr)
 
249
{
 
250
  struct grub_net_network_level_interface *inf;
 
251
  char name[grub_strlen (card->name)
 
252
            + GRUB_NET_MAX_STR_HWADDR_LEN
 
253
            + sizeof (":link")];
 
254
  char *ptr;
 
255
  grub_net_network_level_address_t addr;
 
256
 
 
257
  addr.type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;
 
258
  addr.ipv6[0] = grub_cpu_to_be64 (0xfe80ULL << 48);
 
259
  addr.ipv6[1] = grub_net_ipv6_get_id (hwaddr);
 
260
 
 
261
  FOR_NET_NETWORK_LEVEL_INTERFACES (inf)
 
262
  {
 
263
    if (inf->card == card
 
264
        && grub_net_hwaddr_cmp (&inf->hwaddress, hwaddr) == 0
 
265
        && grub_net_addr_cmp (&inf->address, &addr) == 0)
 
266
      return inf;
 
267
  }
 
268
 
 
269
  ptr = grub_stpcpy (name, card->name);
 
270
  if (grub_net_hwaddr_cmp (&card->default_address, hwaddr) != 0)
 
271
    {
 
272
      ptr = grub_stpcpy (ptr, ":");
 
273
      grub_net_hwaddr_to_str (hwaddr, ptr);
 
274
      ptr += grub_strlen (ptr);
 
275
    }
 
276
  ptr = grub_stpcpy (ptr, ":link");
 
277
  return grub_net_add_addr (name, card, &addr, hwaddr, 0);
 
278
}
 
279
 
 
280
/* FIXME: allow to specify mac address.  */
 
281
static grub_err_t
 
282
grub_cmd_ipv6_autoconf (struct grub_command *cmd __attribute__ ((unused)),
 
283
                        int argc, char **args)
 
284
{
 
285
  struct grub_net_card *card;
 
286
  struct grub_net_network_level_interface **ifaces;
 
287
  grub_size_t ncards = 0;
 
288
  unsigned j = 0;
 
289
  int interval;
 
290
  grub_err_t err;
 
291
  struct grub_net_slaac_mac_list **slaacs;
 
292
 
 
293
  FOR_NET_CARDS (card)
 
294
  {
 
295
    if (argc > 0 && grub_strcmp (card->name, args[0]) != 0)
 
296
      continue;
 
297
    ncards++;
 
298
  }
 
299
 
 
300
  ifaces = grub_zalloc (ncards * sizeof (ifaces[0]));
 
301
  slaacs = grub_zalloc (ncards * sizeof (slaacs[0]));
 
302
  if (!ifaces || !slaacs)
 
303
    {
 
304
      grub_free (ifaces);
 
305
      grub_free (slaacs);
 
306
      return grub_errno;
 
307
    }
 
308
 
 
309
  FOR_NET_CARDS (card)
 
310
  {
 
311
    if (argc > 0 && grub_strcmp (card->name, args[0]) != 0)
 
312
      continue;
 
313
    ifaces[j] = grub_net_ipv6_get_link_local (card, &card->default_address);
 
314
    if (!ifaces[j])
 
315
      {
 
316
        grub_free (ifaces);
 
317
        grub_free (slaacs);
 
318
        return grub_errno;
 
319
      }
 
320
    slaacs[j] = grub_net_ipv6_get_slaac (card, &card->default_address);
 
321
    if (!slaacs[j])
 
322
      {
 
323
        grub_free (ifaces);
 
324
        grub_free (slaacs);
 
325
        return grub_errno;
 
326
      }
 
327
    j++;
 
328
  }
 
329
 
 
330
  for (interval = 200; interval < 10000; interval *= 2)
 
331
    {
 
332
      /* FIXME: send router solicitation.  */
 
333
      int done = 1;
 
334
      for (j = 0; j < ncards; j++)
 
335
        {
 
336
          if (slaacs[j]->slaac_counter)
 
337
            continue;
 
338
          done = 0;
 
339
        }
 
340
      if (done)
 
341
        break;
 
342
      grub_net_poll_cards (interval, 0);
 
343
    }
 
344
 
 
345
  err = GRUB_ERR_NONE;
 
346
  for (j = 0; j < ncards; j++)
 
347
    {
 
348
      if (slaacs[j]->slaac_counter)
 
349
        continue;
 
350
      err = grub_error (GRUB_ERR_FILE_NOT_FOUND,
 
351
                        N_("couldn't autoconfigure %s"),
 
352
                        ifaces[j]->card->name);
 
353
    }
 
354
 
 
355
  grub_free (ifaces);
 
356
  grub_free (slaacs);
 
357
  return err;
 
358
}
 
359
 
 
360
static inline void
 
361
grub_net_route_register (struct grub_net_route *route)
 
362
{
 
363
  grub_list_push (GRUB_AS_LIST_P (&grub_net_routes),
 
364
                  GRUB_AS_LIST (route));
 
365
}
 
366
 
 
367
static inline void
 
368
grub_net_route_unregister (struct grub_net_route *route)
 
369
{
 
370
  grub_list_remove (GRUB_AS_LIST (route));
 
371
}
 
372
 
 
373
#define FOR_NET_ROUTES(var) for (var = grub_net_routes; var; var = var->next)
 
374
 
 
375
static int
 
376
parse_ip (const char *val, grub_uint32_t *ip, const char **rest)
 
377
{
 
378
  grub_uint32_t newip = 0;
 
379
  int i;
 
380
  const char *ptr = val;
 
381
 
 
382
  for (i = 0; i < 4; i++)
 
383
    {
 
384
      unsigned long t;
 
385
      t = grub_strtoul (ptr, (char **) &ptr, 0);
 
386
      if (grub_errno)
 
387
        {
 
388
          grub_errno = GRUB_ERR_NONE;
 
389
          return 0;
 
390
        }
 
391
      if (*ptr != '.' && i == 0)
 
392
        {
 
393
          newip = t;
 
394
          break;
 
395
        }
 
396
      if (t & ~0xff)
 
397
        return 0;
 
398
      newip >>= 8;
 
399
      newip |= (t << 24);
 
400
      if (i != 3 && *ptr != '.')
 
401
        return 0;
 
402
      ptr++;
 
403
    }
 
404
  *ip = grub_cpu_to_le32 (newip);
 
405
  if (rest)
 
406
    *rest = (ptr - 1);
 
407
  return 1;
 
408
}
 
409
 
 
410
static int
 
411
parse_ip6 (const char *val, grub_uint64_t *ip, const char **rest)
 
412
{
 
413
  grub_uint16_t newip[8];
 
414
  const char *ptr = val;
 
415
  int word, quaddot = -1;
 
416
 
 
417
  if (ptr[0] == ':' && ptr[1] != ':')
 
418
    return 0;
 
419
  if (ptr[0] == ':')
 
420
    ptr++;
 
421
 
 
422
  for (word = 0; word < 8; word++)
 
423
    {
 
424
      unsigned long t;
 
425
      if (*ptr == ':')
 
426
        {
 
427
          quaddot = word;
 
428
          word--;
 
429
          ptr++;
 
430
          continue;
 
431
        }
 
432
      t = grub_strtoul (ptr, (char **) &ptr, 16);
 
433
      if (grub_errno)
 
434
        {
 
435
          grub_errno = GRUB_ERR_NONE;
 
436
          break;
 
437
        }
 
438
      if (t & ~0xffff)
 
439
        return 0;
 
440
      newip[word] = grub_cpu_to_be16 (t);
 
441
      if (*ptr != ':')
 
442
        break;
 
443
      ptr++;
 
444
    }
 
445
  if (quaddot == -1 && word < 7)
 
446
    return 0;
 
447
  if (quaddot != -1)
 
448
    {
 
449
      grub_memmove (&newip[quaddot + 7 - word], &newip[quaddot],
 
450
                    (word - quaddot + 1) * sizeof (newip[0]));
 
451
      grub_memset (&newip[quaddot], 0, (7 - word) * sizeof (newip[0]));
 
452
    }
 
453
  grub_memcpy (ip, newip, 16);
 
454
  if (rest)
 
455
    *rest = ptr;
 
456
  return 1;
 
457
}
 
458
 
 
459
static int
 
460
match_net (const grub_net_network_level_netaddress_t *net,
 
461
           const grub_net_network_level_address_t *addr)
 
462
{
 
463
  if (net->type != addr->type)
 
464
    return 0;
 
465
  switch (net->type)
 
466
    {
 
467
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV:
 
468
      return 0;
 
469
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4:
 
470
      {
 
471
        grub_uint32_t mask = (0xffffffffU << (32 - net->ipv4.masksize));
 
472
        if (net->ipv4.masksize == 0)
 
473
          mask = 0;
 
474
        return ((grub_be_to_cpu32 (net->ipv4.base) & mask)
 
475
                == (grub_be_to_cpu32 (addr->ipv4) & mask));
 
476
      }
 
477
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6:
 
478
      {
 
479
        grub_uint64_t mask[2];
 
480
        if (net->ipv6.masksize <= 64)
 
481
          {
 
482
            mask[0] = 0xffffffffffffffffULL << (64 - net->ipv6.masksize);
 
483
            mask[1] = 0;
 
484
          }
 
485
        else 
 
486
          {
 
487
            mask[0] = 0xffffffffffffffffULL;
 
488
            mask[1] = 0xffffffffffffffffULL << (128 - net->ipv6.masksize);
 
489
          }
 
490
        return (((grub_be_to_cpu64 (net->ipv6.base[0]) & mask[0])
 
491
                == (grub_be_to_cpu64 (addr->ipv6[0]) & mask[0]))
 
492
                && ((grub_be_to_cpu64 (net->ipv6.base[1]) & mask[1])
 
493
                    == (grub_be_to_cpu64 (addr->ipv6[1]) & mask[1])));
 
494
      }
 
495
    }
 
496
  return 0;
 
497
}
 
498
 
 
499
grub_err_t
 
500
grub_net_resolve_address (const char *name,
 
501
                          grub_net_network_level_address_t *addr)
 
502
{
 
503
  const char *rest;
 
504
  grub_err_t err;
 
505
  grub_size_t naddresses;
 
506
  struct grub_net_network_level_address *addresses = 0;
 
507
 
 
508
  if (parse_ip (name, &addr->ipv4, &rest) && *rest == 0)
 
509
    {
 
510
      addr->type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4;
 
511
      return GRUB_ERR_NONE;
 
512
    }
 
513
  if (parse_ip6 (name, addr->ipv6, &rest) && *rest == 0)
 
514
    {
 
515
      addr->type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;
 
516
      return GRUB_ERR_NONE;
 
517
    }
 
518
  err = grub_net_dns_lookup (name, 0, 0, &naddresses, &addresses, 1);
 
519
  if (err)
 
520
    return err;
 
521
  if (!naddresses)
 
522
    grub_error (GRUB_ERR_NET_BAD_ADDRESS, N_("unresolvable address %s"),
 
523
                name);
 
524
  /* FIXME: use other results as well.  */
 
525
  *addr = addresses[0];
 
526
  grub_free (addresses);
 
527
  return GRUB_ERR_NONE;
 
528
}
 
529
 
 
530
grub_err_t
 
531
grub_net_resolve_net_address (const char *name,
 
532
                              grub_net_network_level_netaddress_t *addr)
 
533
{
 
534
  const char *rest;
 
535
  if (parse_ip (name, &addr->ipv4.base, &rest))
 
536
    {
 
537
      addr->type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4;
 
538
      if (*rest == '/')
 
539
        {
 
540
          addr->ipv4.masksize = grub_strtoul (rest + 1, (char **) &rest, 0);
 
541
          if (!grub_errno && *rest == 0)
 
542
            return GRUB_ERR_NONE;
 
543
          grub_errno = GRUB_ERR_NONE;
 
544
        }
 
545
      else if (*rest == 0)
 
546
        {
 
547
          addr->ipv4.masksize = 32;
 
548
          return GRUB_ERR_NONE;
 
549
        }
 
550
    }
 
551
  if (parse_ip6 (name, addr->ipv6.base, &rest))
 
552
    {
 
553
      addr->type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;
 
554
      if (*rest == '/')
 
555
        {
 
556
          addr->ipv6.masksize = grub_strtoul (rest + 1, (char **) &rest, 0);
 
557
          if (!grub_errno && *rest == 0)
 
558
            return GRUB_ERR_NONE;
 
559
          grub_errno = GRUB_ERR_NONE;
 
560
        }
 
561
      else if (*rest == 0)
 
562
        {
 
563
          addr->ipv6.masksize = 128;
 
564
          return GRUB_ERR_NONE;
 
565
        }
 
566
    }
 
567
  return grub_error (GRUB_ERR_NET_BAD_ADDRESS,
 
568
                     N_("unrecognised network address `%s'"),
 
569
                     name);
 
570
}
 
571
 
 
572
static int
 
573
route_cmp (const struct grub_net_route *a, const struct grub_net_route *b)
 
574
{
 
575
  if (a == NULL && b == NULL)
 
576
    return 0;
 
577
  if (b == NULL)
 
578
    return +1;
 
579
  if (a == NULL)
 
580
    return -1;
 
581
  if (a->target.type < b->target.type)
 
582
    return -1;
 
583
  if (a->target.type > b->target.type)
 
584
    return +1;
 
585
  switch (a->target.type)
 
586
    {
 
587
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV:
 
588
      break;
 
589
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6:
 
590
      if (a->target.ipv6.masksize > b->target.ipv6.masksize)
 
591
        return +1;
 
592
      if (a->target.ipv6.masksize < b->target.ipv6.masksize)
 
593
        return -1;
 
594
      break;
 
595
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4:
 
596
      if (a->target.ipv4.masksize > b->target.ipv4.masksize)
 
597
        return +1;
 
598
      if (a->target.ipv4.masksize < b->target.ipv4.masksize)
 
599
        return -1;
 
600
      break;
 
601
    }
 
602
  return 0;
 
603
}
 
604
 
 
605
grub_err_t
 
606
grub_net_route_address (grub_net_network_level_address_t addr,
 
607
                        grub_net_network_level_address_t *gateway,
 
608
                        struct grub_net_network_level_interface **interf)
 
609
{
 
610
  struct grub_net_route *route;
 
611
  unsigned int depth = 0;
 
612
  unsigned int routecnt = 0;
 
613
  struct grub_net_network_level_protocol *prot = NULL;
 
614
  grub_net_network_level_address_t curtarget = addr;
 
615
 
 
616
  *gateway = addr;
 
617
 
 
618
  FOR_NET_ROUTES(route)
 
619
    routecnt++;
 
620
 
 
621
  for (depth = 0; depth < routecnt + 2 && depth < GRUB_UINT_MAX; depth++)
 
622
    {
 
623
      struct grub_net_route *bestroute = NULL;
 
624
      FOR_NET_ROUTES(route)
 
625
      {
 
626
        if (depth && prot != route->prot)
 
627
          continue;
 
628
        if (!match_net (&route->target, &curtarget))
 
629
          continue;
 
630
        if (route_cmp (route, bestroute) > 0)
 
631
          bestroute = route;
 
632
      }
 
633
      if (bestroute == NULL)
 
634
        return grub_error (GRUB_ERR_NET_NO_ROUTE,
 
635
                           N_("destination unreachable"));
 
636
 
 
637
      if (!bestroute->is_gateway)
 
638
        {
 
639
          *interf = bestroute->interface;
 
640
          return GRUB_ERR_NONE;
 
641
        }
 
642
      if (depth == 0)
 
643
        *gateway = bestroute->gw;
 
644
      curtarget = bestroute->gw;
 
645
    }
 
646
 
 
647
  return grub_error (GRUB_ERR_NET_ROUTE_LOOP,
 
648
                     /* TRANSLATORS: route loop is a condition when e.g.
 
649
                        to contact server A you need to go through B
 
650
                        and to contact B you need to go through A.  */
 
651
                     N_("route loop detected"));
 
652
}
 
653
 
 
654
static grub_err_t
 
655
grub_cmd_deladdr (struct grub_command *cmd __attribute__ ((unused)),
 
656
                  int argc, char **args)
 
657
{
 
658
  struct grub_net_network_level_interface *inter;
 
659
 
 
660
  if (argc != 1)
 
661
    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
 
662
 
 
663
  FOR_NET_NETWORK_LEVEL_INTERFACES (inter)
 
664
    if (grub_strcmp (inter->name, args[0]) == 0)
 
665
      break;
 
666
  if (inter == NULL)
 
667
    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("address not found"));
 
668
 
 
669
  if (inter->flags & GRUB_NET_INTERFACE_PERMANENT)
 
670
    return grub_error (GRUB_ERR_IO,
 
671
                       N_("you can't delete this address"));
 
672
 
 
673
  grub_net_network_level_interface_unregister (inter);
 
674
  grub_free (inter->name);
 
675
  grub_free (inter);
 
676
 
 
677
  return GRUB_ERR_NONE;  
 
678
}
 
679
 
 
680
void
 
681
grub_net_addr_to_str (const grub_net_network_level_address_t *target, char *buf)
 
682
{
 
683
  switch (target->type)
 
684
    {
 
685
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV:
 
686
      /* TRANSLATORS: it refers to the network address.  */
 
687
      grub_strncpy (buf, "temporary", GRUB_NET_MAX_STR_ADDR_LEN);
 
688
      return;
 
689
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6:
 
690
      {
 
691
        char *ptr = buf;
 
692
        grub_uint64_t n = grub_be_to_cpu64 (target->ipv6[0]);
 
693
        int i;
 
694
        for (i = 0; i < 4; i++)
 
695
          {
 
696
            grub_snprintf (ptr, 6, "%" PRIxGRUB_UINT64_T ":",
 
697
                           (n >> (48 - 16 * i)) & 0xffff);
 
698
            ptr += grub_strlen (ptr); 
 
699
          }
 
700
        n  = grub_be_to_cpu64 (target->ipv6[1]);
 
701
        for (i = 0; i < 3; i++)
 
702
          {
 
703
            grub_snprintf (ptr, 6, "%" PRIxGRUB_UINT64_T ":",
 
704
                           (n >> (48 - 16 * i)) & 0xffff);
 
705
            ptr += grub_strlen (ptr); 
 
706
          }
 
707
        grub_snprintf (ptr, 5, "%" PRIxGRUB_UINT64_T, n & 0xffff);
 
708
        return;
 
709
      }
 
710
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4:
 
711
      {
 
712
        grub_uint32_t n = grub_be_to_cpu32 (target->ipv4);
 
713
        grub_snprintf (buf, GRUB_NET_MAX_STR_ADDR_LEN, "%d.%d.%d.%d",
 
714
                       ((n >> 24) & 0xff), ((n >> 16) & 0xff),
 
715
                       ((n >> 8) & 0xff), ((n >> 0) & 0xff));
 
716
      }
 
717
      return;
 
718
    }
 
719
  grub_snprintf (buf, GRUB_NET_MAX_STR_ADDR_LEN,
 
720
                 "Unknown address type %d", target->type);
 
721
}
 
722
 
 
723
 
 
724
void
 
725
grub_net_hwaddr_to_str (const grub_net_link_level_address_t *addr, char *str)
 
726
{
 
727
  str[0] = 0;
 
728
  switch (addr->type)
 
729
    {
 
730
    case GRUB_NET_LINK_LEVEL_PROTOCOL_ETHERNET:
 
731
      {
 
732
        char *ptr;
 
733
        unsigned i;
 
734
        for (ptr = str, i = 0; i < ARRAY_SIZE (addr->mac); i++)
 
735
          {
 
736
            grub_snprintf (ptr, GRUB_NET_MAX_STR_HWADDR_LEN - (ptr - str),
 
737
                           "%02x:", addr->mac[i] & 0xff);
 
738
            ptr += (sizeof ("XX:") - 1);
 
739
          }
 
740
      return;
 
741
      }
 
742
    }
 
743
  grub_printf (_("Unsupported hw address type %d\n"), addr->type);
 
744
}
 
745
 
 
746
int
 
747
grub_net_hwaddr_cmp (const grub_net_link_level_address_t *a,
 
748
                     const grub_net_link_level_address_t *b)
 
749
{
 
750
  if (a->type < b->type)
 
751
    return -1;
 
752
  if (a->type > b->type)
 
753
    return +1;
 
754
  switch (a->type)
 
755
    {
 
756
    case GRUB_NET_LINK_LEVEL_PROTOCOL_ETHERNET:
 
757
      return grub_memcmp (a->mac, b->mac, sizeof (a->mac));
 
758
    }
 
759
  grub_printf (_("Unsupported hw address type %d\n"), a->type);
 
760
  return 1;
 
761
}
 
762
 
 
763
int
 
764
grub_net_addr_cmp (const grub_net_network_level_address_t *a,
 
765
                   const grub_net_network_level_address_t *b)
 
766
{
 
767
  if (a->type < b->type)
 
768
    return -1;
 
769
  if (a->type > b->type)
 
770
    return +1;
 
771
  switch (a->type)
 
772
    {
 
773
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4:
 
774
      return grub_memcmp (&a->ipv4, &b->ipv4, sizeof (a->ipv4));
 
775
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6:
 
776
      return grub_memcmp (&a->ipv6, &b->ipv6, sizeof (a->ipv6));
 
777
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV:
 
778
      return 0;
 
779
    }
 
780
  grub_printf (_("Unsupported address type %d\n"), a->type);
 
781
  return 1;
 
782
}
 
783
 
 
784
/* FIXME: implement this. */
 
785
static char *
 
786
hwaddr_set_env (struct grub_env_var *var __attribute__ ((unused)),
 
787
                const char *val __attribute__ ((unused)))
 
788
{
 
789
  return NULL;
 
790
}
 
791
 
 
792
/* FIXME: implement this. */
 
793
static char *
 
794
addr_set_env (struct grub_env_var *var __attribute__ ((unused)),
 
795
              const char *val __attribute__ ((unused)))
 
796
{
 
797
  return NULL;
 
798
}
 
799
 
 
800
static char *
 
801
defserver_set_env (struct grub_env_var *var __attribute__ ((unused)),
 
802
                   const char *val)
 
803
{
 
804
  grub_free (grub_net_default_server);
 
805
  grub_net_default_server = grub_strdup (val);
 
806
  return grub_strdup (val);
 
807
}
 
808
 
 
809
static const char *
 
810
defserver_get_env (struct grub_env_var *var __attribute__ ((unused)),
 
811
                   const char *val __attribute__ ((unused)))
 
812
{
 
813
  return grub_net_default_server ? : "";
 
814
}
 
815
 
 
816
 
 
817
static void
 
818
grub_net_network_level_interface_register (struct grub_net_network_level_interface *inter)
 
819
{
 
820
  {
 
821
    char buf[GRUB_NET_MAX_STR_HWADDR_LEN];
 
822
    char name[grub_strlen (inter->name) + sizeof ("net__mac")];
 
823
    char *ptr;
 
824
    grub_net_hwaddr_to_str (&inter->hwaddress, buf);
 
825
    grub_snprintf (name, sizeof (name), "net_%s_mac", inter->name);
 
826
    for (ptr = name; *ptr; ptr++)
 
827
      if (*ptr == ':')
 
828
        *ptr = '_';    
 
829
    grub_env_set (name, buf);
 
830
    grub_register_variable_hook (name, 0, hwaddr_set_env);
 
831
  }
 
832
 
 
833
  {
 
834
    char buf[GRUB_NET_MAX_STR_ADDR_LEN];
 
835
    char name[grub_strlen (inter->name) + sizeof ("net__ip")];
 
836
    char *ptr;
 
837
    grub_net_addr_to_str (&inter->address, buf);
 
838
    grub_snprintf (name, sizeof (name), "net_%s_ip", inter->name);
 
839
    for (ptr = name; *ptr; ptr++)
 
840
      if (*ptr == ':')
 
841
        *ptr = '_';    
 
842
    grub_env_set (name, buf);
 
843
    grub_register_variable_hook (name, 0, addr_set_env);
 
844
  }
 
845
 
 
846
  inter->card->num_ifaces++;
 
847
  inter->prev = &grub_net_network_level_interfaces;
 
848
  inter->next = grub_net_network_level_interfaces;
 
849
  if (inter->next)
 
850
    inter->next->prev = &inter->next;
 
851
  grub_net_network_level_interfaces = inter;
 
852
}
 
853
 
 
854
struct grub_net_network_level_interface *
 
855
grub_net_add_addr (const char *name, 
 
856
                   struct grub_net_card *card,
 
857
                   const grub_net_network_level_address_t *addr,
 
858
                   const grub_net_link_level_address_t *hwaddress,
 
859
                   grub_net_interface_flags_t flags)
 
860
{
 
861
  struct grub_net_network_level_interface *inter;
 
862
 
 
863
  inter = grub_zalloc (sizeof (*inter));
 
864
  if (!inter)
 
865
    return NULL;
 
866
 
 
867
  inter->name = grub_strdup (name);
 
868
  grub_memcpy (&(inter->address), addr, sizeof (inter->address));
 
869
  grub_memcpy (&(inter->hwaddress), hwaddress, sizeof (inter->hwaddress));
 
870
  inter->flags = flags;
 
871
  inter->card = card;
 
872
  inter->dhcp_ack = NULL;
 
873
  inter->dhcp_acklen = 0;
 
874
 
 
875
  grub_net_network_level_interface_register (inter);
 
876
 
 
877
  return inter;
 
878
}
 
879
 
 
880
grub_err_t
 
881
grub_net_add_ipv4_local (struct grub_net_network_level_interface *inter,
 
882
                         int mask)
 
883
{
 
884
  grub_uint32_t ip_cpu;
 
885
  struct grub_net_route *route;
 
886
 
 
887
  if (inter->address.type != GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4)
 
888
    return 0;
 
889
 
 
890
  ip_cpu = grub_be_to_cpu32 (inter->address.ipv4);
 
891
 
 
892
  if (mask == -1)
 
893
    {
 
894
      if (!(ip_cpu & 0x80000000))
 
895
        mask = 8;
 
896
      else if (!(ip_cpu & 0x40000000))
 
897
        mask = 16;
 
898
      else if (!(ip_cpu & 0x20000000))
 
899
        mask = 24;
 
900
    }
 
901
  if (mask == -1)
 
902
    return 0;
 
903
 
 
904
  route = grub_zalloc (sizeof (*route));
 
905
  if (!route)
 
906
    return grub_errno;
 
907
 
 
908
  route->name = grub_xasprintf ("%s:local", inter->name);
 
909
  if (!route->name)
 
910
    {
 
911
      grub_free (route);
 
912
      return grub_errno;
 
913
    }
 
914
 
 
915
  route->target.type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4;
 
916
  route->target.ipv4.base = grub_cpu_to_be32 (ip_cpu & (0xffffffff << (32 - mask)));
 
917
  route->target.ipv4.masksize = mask;
 
918
  route->is_gateway = 0;
 
919
  route->interface = inter;
 
920
 
 
921
  grub_net_route_register (route);
 
922
 
 
923
  return 0;
 
924
}
 
925
 
 
926
/* FIXME: support MAC specifying.  */
 
927
static grub_err_t
 
928
grub_cmd_addaddr (struct grub_command *cmd __attribute__ ((unused)),
 
929
                  int argc, char **args)
 
930
{
 
931
  struct grub_net_card *card;
 
932
  grub_net_network_level_address_t addr;
 
933
  grub_err_t err;
 
934
  grub_net_interface_flags_t flags = 0;
 
935
  struct grub_net_network_level_interface *inf;
 
936
 
 
937
  if (argc != 3)
 
938
    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("three arguments expected"));
 
939
  
 
940
  FOR_NET_CARDS (card)
 
941
    if (grub_strcmp (card->name, args[1]) == 0)
 
942
      break;
 
943
  if (card == NULL)
 
944
    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("card not found")); 
 
945
 
 
946
  err = grub_net_resolve_address (args[2], &addr);
 
947
  if (err)
 
948
    return err;
 
949
 
 
950
  if (card->flags & GRUB_NET_CARD_NO_MANUAL_INTERFACES)
 
951
    return grub_error (GRUB_ERR_IO,
 
952
                       "this card doesn't support address addition");
 
953
 
 
954
  if (card->flags & GRUB_NET_CARD_HWADDRESS_IMMUTABLE)
 
955
    flags |= GRUB_NET_INTERFACE_HWADDRESS_IMMUTABLE;
 
956
 
 
957
  inf = grub_net_add_addr (args[0], card, &addr, &card->default_address,
 
958
                           flags);
 
959
  if (inf)
 
960
    grub_net_add_ipv4_local (inf, -1);
 
961
 
 
962
  return grub_errno;
 
963
}
 
964
 
 
965
static grub_err_t
 
966
grub_cmd_delroute (struct grub_command *cmd __attribute__ ((unused)),
 
967
                   int argc, char **args)
 
968
{
 
969
  struct grub_net_route *route;
 
970
  struct grub_net_route **prev;
 
971
 
 
972
  if (argc != 1)
 
973
    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_("one argument expected"));
 
974
  
 
975
  for (prev = &grub_net_routes, route = *prev; route; prev = &((*prev)->next),
 
976
         route = *prev)
 
977
    if (grub_strcmp (route->name, args[0]) == 0)
 
978
      {
 
979
        *prev = route->next;
 
980
        grub_free (route->name);
 
981
        grub_free (route);
 
982
        if (!*prev)
 
983
          break;
 
984
      }
 
985
 
 
986
  return GRUB_ERR_NONE;
 
987
}
 
988
 
 
989
grub_err_t
 
990
grub_net_add_route (const char *name,
 
991
                    grub_net_network_level_netaddress_t target,
 
992
                    struct grub_net_network_level_interface *inter)
 
993
{
 
994
  struct grub_net_route *route;
 
995
 
 
996
  route = grub_zalloc (sizeof (*route));
 
997
  if (!route)
 
998
    return grub_errno;
 
999
 
 
1000
  route->name = grub_strdup (name);
 
1001
  if (!route->name)
 
1002
    {
 
1003
      grub_free (route);
 
1004
      return grub_errno;
 
1005
    }
 
1006
 
 
1007
  route->target = target;
 
1008
  route->is_gateway = 0;
 
1009
  route->interface = inter;
 
1010
 
 
1011
  grub_net_route_register (route);
 
1012
 
 
1013
  return GRUB_ERR_NONE;
 
1014
}
 
1015
 
 
1016
grub_err_t
 
1017
grub_net_add_route_gw (const char *name,
 
1018
                       grub_net_network_level_netaddress_t target,
 
1019
                       grub_net_network_level_address_t gw)
 
1020
{
 
1021
  struct grub_net_route *route;
 
1022
 
 
1023
  route = grub_zalloc (sizeof (*route));
 
1024
  if (!route)
 
1025
    return grub_errno;
 
1026
 
 
1027
  route->name = grub_strdup (name);
 
1028
  if (!route->name)
 
1029
    {
 
1030
      grub_free (route);
 
1031
      return grub_errno;
 
1032
    }
 
1033
 
 
1034
  route->target = target;
 
1035
  route->is_gateway = 1;
 
1036
  route->gw = gw;
 
1037
 
 
1038
  grub_net_route_register (route);
 
1039
 
 
1040
  return GRUB_ERR_NONE;
 
1041
}
 
1042
 
 
1043
static grub_err_t
 
1044
grub_cmd_addroute (struct grub_command *cmd __attribute__ ((unused)),
 
1045
                  int argc, char **args)
 
1046
{
 
1047
  grub_net_network_level_netaddress_t target;
 
1048
  if (argc < 3)
 
1049
    return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
1050
                       N_("three arguments expected"));
 
1051
 
 
1052
  grub_net_resolve_net_address  (args[1], &target);
 
1053
  
 
1054
  if (grub_strcmp (args[2], "gw") == 0 && argc >= 4)
 
1055
    {
 
1056
      grub_err_t err;
 
1057
      grub_net_network_level_address_t gw;
 
1058
 
 
1059
      err = grub_net_resolve_address (args[3], &gw);
 
1060
      if (err)
 
1061
        return err;
 
1062
      return grub_net_add_route_gw (args[0], target, gw);
 
1063
    }
 
1064
  else
 
1065
    {
 
1066
      struct grub_net_network_level_interface *inter;
 
1067
 
 
1068
      FOR_NET_NETWORK_LEVEL_INTERFACES (inter)
 
1069
        if (grub_strcmp (inter->name, args[2]) == 0)
 
1070
          break;
 
1071
 
 
1072
      if (!inter)
 
1073
        return grub_error (GRUB_ERR_BAD_ARGUMENT,
 
1074
                           N_("unrecognised network interface `%s'"), args[2]);
 
1075
      return grub_net_add_route (args[0], target, inter);
 
1076
    }
 
1077
}
 
1078
 
 
1079
static void
 
1080
print_net_address (const grub_net_network_level_netaddress_t *target)
 
1081
{
 
1082
  switch (target->type)
 
1083
    {
 
1084
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV:
 
1085
      /* TRANSLATORS: it refers to the network address.  */
 
1086
      grub_printf ("%s\n", _("temporary"));
 
1087
      return;
 
1088
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4:
 
1089
      {
 
1090
        grub_uint32_t n = grub_be_to_cpu32 (target->ipv4.base);
 
1091
        grub_printf ("%d.%d.%d.%d/%d ", ((n >> 24) & 0xff),
 
1092
                     ((n >> 16) & 0xff),
 
1093
                     ((n >> 8) & 0xff),
 
1094
                     ((n >> 0) & 0xff),
 
1095
                     target->ipv4.masksize);
 
1096
      }
 
1097
      return;
 
1098
    case GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6:
 
1099
      {
 
1100
        char buf[GRUB_NET_MAX_STR_ADDR_LEN];
 
1101
        struct grub_net_network_level_address base;
 
1102
        base.type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6;
 
1103
        grub_memcpy (&base.ipv6, &target->ipv6, 16);
 
1104
        grub_net_addr_to_str (&base, buf);
 
1105
        grub_printf ("%s/%d ", buf, target->ipv6.masksize);
 
1106
      }
 
1107
      return;
 
1108
    }
 
1109
  grub_printf (_("Unknown address type %d\n"), target->type);
 
1110
}
 
1111
 
 
1112
static void
 
1113
print_address (const grub_net_network_level_address_t *target)
 
1114
{
 
1115
  char buf[GRUB_NET_MAX_STR_ADDR_LEN];
 
1116
  grub_net_addr_to_str (target, buf);
 
1117
  grub_xputs (buf);
 
1118
}
 
1119
 
 
1120
static grub_err_t
 
1121
grub_cmd_listroutes (struct grub_command *cmd __attribute__ ((unused)),
 
1122
                     int argc __attribute__ ((unused)),
 
1123
                     char **args __attribute__ ((unused)))
 
1124
{
 
1125
  struct grub_net_route *route;
 
1126
  FOR_NET_ROUTES(route)
 
1127
  {
 
1128
    grub_printf ("%s ", route->name);
 
1129
    print_net_address (&route->target);
 
1130
    if (route->is_gateway)
 
1131
      {
 
1132
        grub_printf ("gw ");
 
1133
        print_address (&route->gw);     
 
1134
      }
 
1135
    else
 
1136
      grub_printf ("%s", route->interface->name);      
 
1137
    grub_printf ("\n");
 
1138
  }
 
1139
  return GRUB_ERR_NONE;
 
1140
}
 
1141
 
 
1142
static grub_err_t
 
1143
grub_cmd_listcards (struct grub_command *cmd __attribute__ ((unused)),
 
1144
                    int argc __attribute__ ((unused)),
 
1145
                    char **args __attribute__ ((unused)))
 
1146
{
 
1147
  struct grub_net_card *card;
 
1148
  FOR_NET_CARDS(card)
 
1149
  {
 
1150
    char buf[GRUB_NET_MAX_STR_HWADDR_LEN];
 
1151
    grub_net_hwaddr_to_str (&card->default_address, buf);
 
1152
    grub_printf ("%s %s\n", card->name, buf);
 
1153
  }
 
1154
  return GRUB_ERR_NONE;
 
1155
}
 
1156
 
 
1157
static grub_err_t
 
1158
grub_cmd_listaddrs (struct grub_command *cmd __attribute__ ((unused)),
 
1159
                    int argc __attribute__ ((unused)),
 
1160
                    char **args __attribute__ ((unused)))
 
1161
{
 
1162
  struct grub_net_network_level_interface *inf;
 
1163
  FOR_NET_NETWORK_LEVEL_INTERFACES (inf)
 
1164
  {
 
1165
    char bufh[GRUB_NET_MAX_STR_HWADDR_LEN];
 
1166
    char bufn[GRUB_NET_MAX_STR_ADDR_LEN];
 
1167
    grub_net_hwaddr_to_str (&inf->hwaddress, bufh);
 
1168
    grub_net_addr_to_str (&inf->address, bufn);
 
1169
    grub_printf ("%s %s %s\n", inf->name, bufh, bufn);
 
1170
  }
 
1171
  return GRUB_ERR_NONE;
 
1172
}
 
1173
 
 
1174
grub_net_app_level_t grub_net_app_level_list;
 
1175
struct grub_net_socket *grub_net_sockets;
 
1176
 
 
1177
static grub_net_t
 
1178
grub_net_open_real (const char *name)
 
1179
{
 
1180
  grub_net_app_level_t proto;
 
1181
  const char *protname, *server;
 
1182
  grub_size_t protnamelen;
 
1183
 
 
1184
  if (grub_strncmp (name, "pxe:", sizeof ("pxe:") - 1) == 0)
 
1185
    {
 
1186
      protname = "tftp";
 
1187
      protnamelen = sizeof ("tftp") - 1;
 
1188
      server = name + sizeof ("pxe:") - 1;
 
1189
    }
 
1190
  else if (grub_strcmp (name, "pxe") == 0)
 
1191
    {
 
1192
      protname = "tftp";
 
1193
      protnamelen = sizeof ("tftp") - 1;
 
1194
      server = grub_net_default_server;
 
1195
    }
 
1196
  else
 
1197
    {
 
1198
      const char *comma;
 
1199
      comma = grub_strchr (name, ',');
 
1200
      if (comma)
 
1201
        {
 
1202
          protnamelen = comma - name;
 
1203
          server = comma + 1;
 
1204
          protname = name;
 
1205
        }
 
1206
      else
 
1207
        {
 
1208
          protnamelen = grub_strlen (name);
 
1209
          server = grub_net_default_server;
 
1210
          protname = name;
 
1211
        }
 
1212
    }
 
1213
  if (!server)
 
1214
    {
 
1215
      grub_error (GRUB_ERR_NET_BAD_ADDRESS,
 
1216
                  N_("no server is specified"));
 
1217
      return NULL;
 
1218
    }  
 
1219
 
 
1220
  FOR_NET_APP_LEVEL (proto)
 
1221
  {
 
1222
    if (grub_memcmp (proto->name, protname, protnamelen) == 0
 
1223
        && proto->name[protnamelen] == 0)
 
1224
      {
 
1225
        grub_net_t ret = grub_zalloc (sizeof (*ret));
 
1226
        if (!ret)
 
1227
          return NULL;
 
1228
        ret->protocol = proto;
 
1229
        if (server)
 
1230
          {
 
1231
            ret->server = grub_strdup (server);
 
1232
            if (!ret->server)
 
1233
              {
 
1234
                grub_free (ret);
 
1235
                return NULL;
 
1236
              }
 
1237
          }
 
1238
        else
 
1239
          ret->server = NULL;
 
1240
        ret->fs = &grub_net_fs;
 
1241
        ret->offset = 0;
 
1242
        ret->eof = 0;
 
1243
        return ret;
 
1244
      }
 
1245
  }
 
1246
 
 
1247
  /* Restore original error.  */
 
1248
  grub_error (GRUB_ERR_UNKNOWN_DEVICE, N_("disk `%s' not found"),
 
1249
              name);
 
1250
 
 
1251
  return NULL;
 
1252
}
 
1253
 
 
1254
static grub_err_t
 
1255
grub_net_fs_dir (grub_device_t device, const char *path __attribute__ ((unused)),
 
1256
               int (*hook) (const char *filename,
 
1257
                            const struct grub_dirhook_info *info) __attribute__ ((unused)))
 
1258
{
 
1259
  if (!device->net)
 
1260
    return grub_error (GRUB_ERR_BUG, "invalid net device");
 
1261
  return GRUB_ERR_NONE;
 
1262
}
 
1263
 
 
1264
static grub_err_t
 
1265
grub_net_fs_open (struct grub_file *file_out, const char *name)
 
1266
{
 
1267
  grub_err_t err;
 
1268
  struct grub_file *file, *bufio;
 
1269
 
 
1270
  file = grub_malloc (sizeof (*file));
 
1271
  if (!file)
 
1272
    return grub_errno;
 
1273
 
 
1274
  grub_memcpy (file, file_out, sizeof (struct grub_file));
 
1275
  file->device->net->packs.first = NULL;
 
1276
  file->device->net->packs.last = NULL;
 
1277
  file->device->net->name = grub_strdup (name);
 
1278
  if (!file->device->net->name)
 
1279
    return grub_errno;
 
1280
 
 
1281
  err = file->device->net->protocol->open (file, name);
 
1282
  if (err)
 
1283
    {
 
1284
      while (file->device->net->packs.first)
 
1285
        {
 
1286
          grub_netbuff_free (file->device->net->packs.first->nb);
 
1287
          grub_net_remove_packet (file->device->net->packs.first);
 
1288
        }
 
1289
      grub_free (file->device->net->name);
 
1290
      grub_free (file);
 
1291
      return err;
 
1292
    }
 
1293
  bufio = grub_bufio_open (file, 32768);
 
1294
  if (! bufio)
 
1295
    {
 
1296
      while (file->device->net->packs.first)
 
1297
        {
 
1298
          grub_netbuff_free (file->device->net->packs.first->nb);
 
1299
          grub_net_remove_packet (file->device->net->packs.first);
 
1300
        }
 
1301
      file->device->net->protocol->close (file);
 
1302
      grub_free (file->device->net->name);
 
1303
      grub_free (file);
 
1304
      return grub_errno;
 
1305
    }
 
1306
 
 
1307
  grub_memcpy (file_out, bufio, sizeof (struct grub_file));
 
1308
  grub_free (bufio);
 
1309
  return GRUB_ERR_NONE;
 
1310
}
 
1311
 
 
1312
static grub_err_t
 
1313
grub_net_fs_close (grub_file_t file)
 
1314
{
 
1315
  while (file->device->net->packs.first)
 
1316
    {
 
1317
      grub_netbuff_free (file->device->net->packs.first->nb);
 
1318
      grub_net_remove_packet (file->device->net->packs.first);
 
1319
    }
 
1320
  file->device->net->protocol->close (file);
 
1321
  grub_free (file->device->net->name);
 
1322
  return GRUB_ERR_NONE;
 
1323
}
 
1324
 
 
1325
static void
 
1326
receive_packets (struct grub_net_card *card, int *stop_condition)
 
1327
{
 
1328
  int received = 0;
 
1329
  if (card->num_ifaces == 0)
 
1330
    return;
 
1331
  if (!card->opened)
 
1332
    {
 
1333
      grub_err_t err = GRUB_ERR_NONE;
 
1334
      if (card->driver->open)
 
1335
        err = card->driver->open (card);
 
1336
      if (err)
 
1337
        {
 
1338
          grub_errno = GRUB_ERR_NONE;
 
1339
          return;
 
1340
        }
 
1341
      card->opened = 1;
 
1342
    }
 
1343
  while (1)
 
1344
    {
 
1345
      /* Maybe should be better have a fixed number of packets for each card
 
1346
         and just mark them as used and not used.  */ 
 
1347
      struct grub_net_buff *nb;
 
1348
 
 
1349
      if (received > 10 && stop_condition && *stop_condition)
 
1350
        break;
 
1351
 
 
1352
      nb = card->driver->recv (card);
 
1353
      if (!nb)
 
1354
        {
 
1355
          card->last_poll = grub_get_time_ms ();
 
1356
          break;
 
1357
        }
 
1358
      received++;
 
1359
      grub_net_recv_ethernet_packet (nb, card);
 
1360
      if (grub_errno)
 
1361
        {
 
1362
          grub_dprintf ("net", "error receiving: %d: %s\n", grub_errno,
 
1363
                        grub_errmsg);
 
1364
          grub_errno = GRUB_ERR_NONE;
 
1365
        }
 
1366
    }
 
1367
  grub_print_error ();
 
1368
}
 
1369
 
 
1370
void
 
1371
grub_net_poll_cards (unsigned time, int *stop_condition)
 
1372
{
 
1373
  struct grub_net_card *card;
 
1374
  grub_uint64_t start_time;
 
1375
  start_time = grub_get_time_ms ();
 
1376
  while ((grub_get_time_ms () - start_time) < time
 
1377
         && (!stop_condition || !*stop_condition))
 
1378
    FOR_NET_CARDS (card)
 
1379
      receive_packets (card, stop_condition);
 
1380
  grub_net_tcp_retransmit ();
 
1381
}
 
1382
 
 
1383
static void
 
1384
grub_net_poll_cards_idle_real (void)
 
1385
{
 
1386
  struct grub_net_card *card;
 
1387
  FOR_NET_CARDS (card)
 
1388
  {
 
1389
    grub_uint64_t ctime = grub_get_time_ms ();
 
1390
 
 
1391
    if (ctime < card->last_poll
 
1392
        || ctime >= card->last_poll + card->idle_poll_delay_ms)
 
1393
      receive_packets (card, 0);
 
1394
  }
 
1395
  grub_net_tcp_retransmit ();
 
1396
}
 
1397
 
 
1398
/*  Read from the packets list*/
 
1399
static grub_ssize_t
 
1400
grub_net_fs_read_real (grub_file_t file, char *buf, grub_size_t len)
 
1401
{
 
1402
  grub_net_t net = file->device->net;
 
1403
  struct grub_net_buff *nb;
 
1404
  char *ptr = buf;
 
1405
  grub_size_t amount, total = 0;
 
1406
  int try = 0;
 
1407
 
 
1408
  while (try <= GRUB_NET_TRIES)
 
1409
    {
 
1410
      while (net->packs.first)
 
1411
        {
 
1412
          try = 0;
 
1413
          nb = net->packs.first->nb;
 
1414
          amount = nb->tail - nb->data;
 
1415
          if (amount > len)
 
1416
            amount = len;
 
1417
          len -= amount;
 
1418
          total += amount;
 
1419
          file->device->net->offset += amount;
 
1420
          if (buf)
 
1421
            {
 
1422
              grub_memcpy (ptr, nb->data, amount);
 
1423
              ptr += amount;
 
1424
            }
 
1425
          if (amount == (grub_size_t) (nb->tail - nb->data))
 
1426
            {
 
1427
              grub_netbuff_free (nb);
 
1428
              grub_net_remove_packet (net->packs.first);
 
1429
            }
 
1430
          else
 
1431
            nb->data += amount;
 
1432
 
 
1433
          if (!len)
 
1434
            {
 
1435
              if (net->protocol->packets_pulled)
 
1436
                net->protocol->packets_pulled (file);
 
1437
              return total;
 
1438
            }
 
1439
        }
 
1440
      if (net->protocol->packets_pulled)
 
1441
        net->protocol->packets_pulled (file);
 
1442
 
 
1443
      if (!net->eof)
 
1444
        {
 
1445
          try++;
 
1446
          grub_net_poll_cards (GRUB_NET_INTERVAL, &net->stall);
 
1447
        }
 
1448
      else
 
1449
        return total;
 
1450
    }
 
1451
  grub_error (GRUB_ERR_TIMEOUT, N_("timeout reading `%s'"), net->name);
 
1452
  return -1;
 
1453
}
 
1454
 
 
1455
static grub_off_t
 
1456
have_ahead (struct grub_file *file)
 
1457
{
 
1458
  grub_net_t net = file->device->net;
 
1459
  grub_off_t ret = net->offset;
 
1460
  struct grub_net_packet *pack;
 
1461
  for (pack = net->packs.first; pack; pack = pack->next)
 
1462
    ret += pack->nb->tail - pack->nb->data;
 
1463
  return ret;
 
1464
}
 
1465
 
 
1466
static grub_err_t 
 
1467
grub_net_seek_real (struct grub_file *file, grub_off_t offset)
 
1468
{
 
1469
  if (offset == file->device->net->offset)
 
1470
    return GRUB_ERR_NONE;
 
1471
 
 
1472
  if (offset > file->device->net->offset)
 
1473
    {
 
1474
      if (!file->device->net->protocol->seek || have_ahead (file) >= offset)
 
1475
        {
 
1476
          grub_net_fs_read_real (file, NULL,
 
1477
                                 offset - file->device->net->offset);
 
1478
          return grub_errno;
 
1479
        }
 
1480
      return file->device->net->protocol->seek (file, offset);
 
1481
    }
 
1482
 
 
1483
  {
 
1484
    grub_err_t err;
 
1485
    if (file->device->net->protocol->seek)
 
1486
      return file->device->net->protocol->seek (file, offset);
 
1487
    while (file->device->net->packs.first)
 
1488
      {
 
1489
        grub_netbuff_free (file->device->net->packs.first->nb);
 
1490
        grub_net_remove_packet (file->device->net->packs.first);
 
1491
      }
 
1492
    file->device->net->protocol->close (file);
 
1493
 
 
1494
    file->device->net->packs.first = NULL;
 
1495
    file->device->net->packs.last = NULL;
 
1496
    file->device->net->offset = 0;
 
1497
    file->device->net->eof = 0;
 
1498
    err = file->device->net->protocol->open (file, file->device->net->name);
 
1499
    if (err)
 
1500
      return err;
 
1501
    grub_net_fs_read_real (file, NULL, offset);
 
1502
    return grub_errno;
 
1503
  }
 
1504
}
 
1505
 
 
1506
static grub_ssize_t
 
1507
grub_net_fs_read (grub_file_t file, char *buf, grub_size_t len)
 
1508
{
 
1509
  if (file->offset != file->device->net->offset)
 
1510
    {
 
1511
      grub_err_t err;
 
1512
      err = grub_net_seek_real (file, file->offset);
 
1513
      if (err)
 
1514
        return err;
 
1515
    }
 
1516
  return grub_net_fs_read_real (file, buf, len);
 
1517
}
 
1518
 
 
1519
static struct grub_fs grub_net_fs =
 
1520
  {
 
1521
    .name = "netfs",
 
1522
    .dir = grub_net_fs_dir,
 
1523
    .open = grub_net_fs_open,
 
1524
    .read = grub_net_fs_read,
 
1525
    .close = grub_net_fs_close,
 
1526
    .label = NULL,
 
1527
    .uuid = NULL,
 
1528
    .mtime = NULL,
 
1529
  };
 
1530
 
 
1531
static grub_err_t
 
1532
grub_net_fini_hw (int noreturn __attribute__ ((unused)))
 
1533
{
 
1534
  struct grub_net_card *card;
 
1535
  FOR_NET_CARDS (card) 
 
1536
    if (card->opened)
 
1537
      {
 
1538
        if (card->driver->close)
 
1539
          card->driver->close (card);
 
1540
        card->opened = 0;
 
1541
      }
 
1542
  return GRUB_ERR_NONE;
 
1543
}
 
1544
 
 
1545
static grub_err_t
 
1546
grub_net_restore_hw (void)
 
1547
{
 
1548
  return GRUB_ERR_NONE;
 
1549
}
 
1550
 
 
1551
static struct grub_preboot *fini_hnd;
 
1552
 
 
1553
static grub_command_t cmd_addaddr, cmd_deladdr, cmd_addroute, cmd_delroute;
 
1554
static grub_command_t cmd_lsroutes, cmd_lscards;
 
1555
static grub_command_t cmd_lsaddr, cmd_slaac;
 
1556
 
 
1557
GRUB_MOD_INIT(net)
 
1558
{
 
1559
  grub_register_variable_hook ("net_default_server", defserver_get_env,
 
1560
                               defserver_set_env);
 
1561
  grub_register_variable_hook ("pxe_default_server", defserver_get_env,
 
1562
                               defserver_set_env);
 
1563
 
 
1564
  cmd_addaddr = grub_register_command ("net_add_addr", grub_cmd_addaddr,
 
1565
                                        /* TRANSLATORS: HWADDRESS stands for
 
1566
                                           "hardware address".  */
 
1567
                                       N_("SHORTNAME CARD ADDRESS [HWADDRESS]"),
 
1568
                                       N_("Add a network address."));
 
1569
  cmd_slaac = grub_register_command ("net_ipv6_autoconf",
 
1570
                                     grub_cmd_ipv6_autoconf,
 
1571
                                     N_("[CARD [HWADDRESS]]"),
 
1572
                                     N_("Perform an IPV6 autoconfiguration"));
 
1573
 
 
1574
  cmd_deladdr = grub_register_command ("net_del_addr", grub_cmd_deladdr,
 
1575
                                       N_("SHORTNAME"),
 
1576
                                       N_("Delete a network address."));
 
1577
  cmd_addroute = grub_register_command ("net_add_route", grub_cmd_addroute,
 
1578
                                        /* TRANSLATORS: "gw" is a keyword.  */
 
1579
                                        N_("SHORTNAME NET [INTERFACE| gw GATEWAY]"),
 
1580
                                        N_("Add a network route."));
 
1581
  cmd_delroute = grub_register_command ("net_del_route", grub_cmd_delroute,
 
1582
                                        N_("SHORTNAME"),
 
1583
                                        N_("Delete a network route."));
 
1584
  cmd_lsroutes = grub_register_command ("net_ls_routes", grub_cmd_listroutes,
 
1585
                                        "", N_("list network routes"));
 
1586
  cmd_lscards = grub_register_command ("net_ls_cards", grub_cmd_listcards,
 
1587
                                       "", N_("list network cards"));
 
1588
  cmd_lsaddr = grub_register_command ("net_ls_addr", grub_cmd_listaddrs,
 
1589
                                       "", N_("list network addresses"));
 
1590
  grub_bootp_init ();
 
1591
  grub_dns_init ();
 
1592
 
 
1593
  grub_net_open = grub_net_open_real;
 
1594
  fini_hnd = grub_loader_register_preboot_hook (grub_net_fini_hw,
 
1595
                                                grub_net_restore_hw,
 
1596
                                                GRUB_LOADER_PREBOOT_HOOK_PRIO_DISK);
 
1597
  grub_net_poll_cards_idle = grub_net_poll_cards_idle_real;
 
1598
}
 
1599
 
 
1600
GRUB_MOD_FINI(net)
 
1601
{
 
1602
  grub_register_variable_hook ("net_default_server", 0, 0);
 
1603
  grub_register_variable_hook ("pxe_default_server", 0, 0);
 
1604
 
 
1605
  grub_bootp_fini ();
 
1606
  grub_dns_fini ();
 
1607
  grub_unregister_command (cmd_addaddr);
 
1608
  grub_unregister_command (cmd_deladdr);
 
1609
  grub_unregister_command (cmd_addroute);
 
1610
  grub_unregister_command (cmd_delroute);
 
1611
  grub_unregister_command (cmd_lsroutes);
 
1612
  grub_unregister_command (cmd_lscards);
 
1613
  grub_unregister_command (cmd_lsaddr);
 
1614
  grub_unregister_command (cmd_slaac);
 
1615
  grub_fs_unregister (&grub_net_fs);
 
1616
  grub_net_open = NULL;
 
1617
  grub_net_fini_hw (0);
 
1618
  grub_loader_unregister_preboot_hook (fini_hnd);
 
1619
  grub_net_poll_cards_idle = grub_net_poll_cards_idle_real;
 
1620
}