include/grub/net.h

   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 #ifndef GRUB_NET_HEADER
  20 #define GRUB_NET_HEADER 1
  21
  22 #include <grub/types.h>
  23 #include <grub/err.h>
  24 #include <grub/list.h>
  25 #include <grub/fs.h>
  26 #include <grub/file.h>
  27 #include <grub/mm.h>
  28 #include <grub/net/netbuff.h>
  29
  30 enum
  31   {
  32     GRUB_NET_MAX_LINK_HEADER_SIZE = 64,
  33     GRUB_NET_UDP_HEADER_SIZE = 8,
  34     GRUB_NET_TCP_HEADER_SIZE = 20,
  35     GRUB_NET_OUR_IPV4_HEADER_SIZE = 20,
  36     GRUB_NET_OUR_IPV6_HEADER_SIZE = 40,
  37     GRUB_NET_OUR_MAX_IP_HEADER_SIZE = 40,
  38     GRUB_NET_TCP_RESERVE_SIZE = GRUB_NET_TCP_HEADER_SIZE
  39     + GRUB_NET_OUR_IPV4_HEADER_SIZE
  40     + GRUB_NET_MAX_LINK_HEADER_SIZE
  41   };
  42
  43 typedef enum grub_link_level_protocol_id
  44 {
  45   GRUB_NET_LINK_LEVEL_PROTOCOL_ETHERNET
  46 } grub_link_level_protocol_id_t;
  47
  48 typedef struct grub_net_link_level_address
  49 {
  50   grub_link_level_protocol_id_t type;
  51   union
  52   {
  53     grub_uint8_t mac[6];
  54   };
  55 } grub_net_link_level_address_t;
  56
  57 typedef enum grub_net_interface_flags
  58   {
  59     GRUB_NET_INTERFACE_HWADDRESS_IMMUTABLE = 1,
  60     GRUB_NET_INTERFACE_ADDRESS_IMMUTABLE = 2,
  61     GRUB_NET_INTERFACE_PERMANENT = 4
  62   } grub_net_interface_flags_t;
  63
  64 typedef enum grub_net_card_flags
  65   {
  66     GRUB_NET_CARD_HWADDRESS_IMMUTABLE = 1,
  67     GRUB_NET_CARD_NO_MANUAL_INTERFACES = 2
  68   } grub_net_card_flags_t;
  69
  70 struct grub_net_card;
  71
  72 struct grub_net_card_driver
  73 {
  74   struct grub_net_card_driver *next;
  75   struct grub_net_card_driver **prev;
  76   const char *name;
  77   grub_err_t (*open) (struct grub_net_card *dev);
  78   void (*close) (struct grub_net_card *dev);
  79   grub_err_t (*send) (struct grub_net_card *dev,
  80                       struct grub_net_buff *buf);
  81   struct grub_net_buff * (*recv) (struct grub_net_card *dev);
  82 };
  83
  84 typedef struct grub_net_packet
  85 {
  86   struct grub_net_packet *next;
  87   struct grub_net_packet *prev;
  88   struct grub_net_packets *up;
  89   struct grub_net_buff *nb;
  90 } grub_net_packet_t;
  91
  92 typedef struct grub_net_packets
  93 {
  94   grub_net_packet_t *first;
  95   grub_net_packet_t *last;
  96   grub_size_t count;
  97 } grub_net_packets_t;
  98
  99 #ifdef GRUB_MACHINE_EFI
 100 #include <grub/efi/api.h>
 101 #endif
 102
 103 struct grub_net_slaac_mac_list
 104 {
 105   struct grub_net_slaac_mac_list *next;
 106   struct grub_net_slaac_mac_list **prev;
 107   grub_net_link_level_address_t address;
 108   int slaac_counter;
 109   char *name;
 110 };
 111
 112 struct grub_net_link_layer_entry;
 113
 114 struct grub_net_card
 115 {
 116   struct grub_net_card *next;
 117   struct grub_net_card **prev;
 118   const char *name;
 119   struct grub_net_card_driver *driver;
 120   grub_net_link_level_address_t default_address;
 121   grub_net_card_flags_t flags;
 122   int num_ifaces;
 123   int opened;
 124   unsigned idle_poll_delay_ms;
 125   grub_uint64_t last_poll;
 126   grub_size_t mtu;
 127   struct grub_net_slaac_mac_list *slaac_list;
 128   grub_ssize_t new_ll_entry;
 129   struct grub_net_link_layer_entry *link_layer_table;
 130   void *txbuf;
 131   void *rcvbuf;
 132   grub_size_t rcvbufsize;
 133   grub_size_t txbufsize;
 134   int txbusy;
 135   union
 136   {
 137 #ifdef GRUB_MACHINE_EFI
 138     struct
 139     {
 140       struct grub_efi_simple_network *efi_net;
 141       grub_efi_handle_t efi_handle;
 142       grub_size_t last_pkt_size;
 143     };
 144 #endif
 145     void *data;
 146     int data_num;
 147   };
 148 };
 149
 150 struct grub_net_network_level_interface;
 151
 152 typedef enum grub_network_level_protocol_id
 153 {
 154   GRUB_NET_NETWORK_LEVEL_PROTOCOL_DHCP_RECV,
 155   GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4,
 156   GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6
 157 } grub_network_level_protocol_id_t;
 158
 159 typedef enum
 160 {
 161   DNS_OPTION_IPV4,
 162   DNS_OPTION_IPV6,
 163   DNS_OPTION_PREFER_IPV4,
 164   DNS_OPTION_PREFER_IPV6
 165 } grub_dns_option_t;
 166
 167 typedef struct grub_net_network_level_address
 168 {
 169   grub_network_level_protocol_id_t type;
 170   union
 171   {
 172     grub_uint32_t ipv4;
 173     grub_uint64_t ipv6[2];
 174   };
 175   grub_dns_option_t option;
 176 } grub_net_network_level_address_t;
 177
 178 typedef struct grub_net_network_level_netaddress
 179 {
 180   grub_network_level_protocol_id_t type;
 181   union
 182   {
 183     struct {
 184       grub_uint32_t base;
 185       int masksize;
 186     } ipv4;
 187     struct {
 188       grub_uint64_t base[2];
 189       int masksize;
 190     } ipv6;
 191   };
 192 } grub_net_network_level_netaddress_t;
 193
 194 #define FOR_PACKETS(cont,var) for (var = (cont).first; var; var = var->next)
 195
 196 static inline grub_err_t
 197 grub_net_put_packet (grub_net_packets_t *pkts, struct grub_net_buff *nb)
 198 {
 199   struct grub_net_packet *n;
 200
 201   n = grub_malloc (sizeof (*n));
 202   if (!n)
 203     return grub_errno;
 204
 205   n->nb = nb;
 206   n->next = NULL;
 207   n->prev = NULL;
 208   n->up = pkts;
 209   if (pkts->first)
 210     {
 211       pkts->last->next = n;
 212       pkts->last = n;
 213       n->prev = pkts->last;
 214     }
 215   else
 216     pkts->first = pkts->last = n;
 217
 218   pkts->count++;
 219
 220   return GRUB_ERR_NONE;
 221 }
 222
 223 static inline void
 224 grub_net_remove_packet (grub_net_packet_t *pkt)
 225 {
 226   pkt->up->count--;
 227
 228   if (pkt->prev)
 229     pkt->prev->next = pkt->next;
 230   else
 231     pkt->up->first = pkt->next;
 232   if (pkt->next)
 233     pkt->next->prev = pkt->prev;
 234   else
 235     pkt->up->last = pkt->prev;
 236   grub_free (pkt);
 237 }
 238
 239 typedef struct grub_net_app_protocol *grub_net_app_level_t;
 240
 241 typedef struct grub_net_socket *grub_net_socket_t;
 242
 243 struct grub_net_app_protocol
 244 {
 245   struct grub_net_app_protocol *next;
 246   struct grub_net_app_protocol **prev;
 247   const char *name;
 248   grub_err_t (*dir) (grub_device_t device, const char *path,
 249                      int (*hook) (const char *filename,
 250                                   const struct grub_dirhook_info *info));
 251   grub_err_t (*open) (struct grub_file *file, const char *filename);
 252   grub_err_t (*seek) (struct grub_file *file, grub_off_t off);
 253   grub_err_t (*close) (struct grub_file *file);
 254   grub_err_t (*packets_pulled) (struct grub_file *file);
 255 };
 256
 257 typedef struct grub_net
 258 {
 259   char *server;
 260   char *name;
 261   grub_net_app_level_t protocol;
 262   grub_net_packets_t packs;
 263   grub_off_t offset;
 264   grub_fs_t fs;
 265   int eof;
 266   int stall;
 267 } *grub_net_t;
 268
 269 extern grub_net_t (*EXPORT_VAR (grub_net_open)) (const char *name);
 270
 271 struct grub_net_network_level_interface
 272 {
 273   struct grub_net_network_level_interface *next;
 274   struct grub_net_network_level_interface **prev;
 275   char *name;
 276   struct grub_net_card *card;
 277   grub_net_network_level_address_t address;
 278   grub_net_link_level_address_t hwaddress;
 279   grub_net_interface_flags_t flags;
 280   struct grub_net_bootp_packet *dhcp_ack;
 281   grub_size_t dhcp_acklen;
 282   void *data;
 283 };
 284
 285 struct grub_net_session;
 286
 287 struct grub_net_session_level_protocol
 288 {
 289   void (*close) (struct grub_net_session *session);
 290   grub_ssize_t (*recv) (struct grub_net_session *session, void *buf,
 291                        grub_size_t size);
 292   grub_err_t (*send) (struct grub_net_session *session, void *buf,
 293                       grub_size_t size);
 294 };
 295
 296 struct grub_net_session
 297 {
 298   struct grub_net_session_level_protocol *protocol;
 299   void *data;
 300 };
 301
 302 static inline void
 303 grub_net_session_close (struct grub_net_session *session)
 304 {
 305   session->protocol->close (session);
 306 }
 307
 308 static inline grub_err_t
 309 grub_net_session_send (struct grub_net_session *session, void *buf,
 310                        grub_size_t size)
 311 {
 312   return session->protocol->send (session, buf, size);
 313 }
 314
 315 static inline grub_ssize_t
 316 grub_net_session_recv (struct grub_net_session *session, void *buf,
 317                        grub_size_t size)
 318 {
 319   return session->protocol->recv (session, buf, size);
 320 }
 321
 322 struct grub_net_network_level_interface *
 323 grub_net_add_addr (const char *name,
 324                    struct grub_net_card *card,
 325                    const grub_net_network_level_address_t *addr,
 326                    const grub_net_link_level_address_t *hwaddress,
 327                    grub_net_interface_flags_t flags);
 328
 329 extern struct grub_net_network_level_interface *grub_net_network_level_interfaces;
 330 #define FOR_NET_NETWORK_LEVEL_INTERFACES(var) for (var = grub_net_network_level_interfaces; var; var = var->next)
 331 #define FOR_NET_NETWORK_LEVEL_INTERFACES_SAFE(var,next) for (var = grub_net_network_level_interfaces, next = (var ? var->next : 0); var; var = next, next = (var ? var->next : 0))
 332
 333
 334 extern grub_net_app_level_t grub_net_app_level_list;
 335
 336 #ifndef GRUB_LST_GENERATOR
 337 static inline void
 338 grub_net_app_level_register (grub_net_app_level_t proto)
 339 {
 340   grub_list_push (GRUB_AS_LIST_P (&grub_net_app_level_list),
 341                   GRUB_AS_LIST (proto));
 342 }
 343 #endif
 344
 345 static inline void
 346 grub_net_app_level_unregister (grub_net_app_level_t proto)
 347 {
 348   grub_list_remove (GRUB_AS_LIST (proto));
 349 }
 350
 351 #define FOR_NET_APP_LEVEL(var) FOR_LIST_ELEMENTS((var), \
 352                                                  (grub_net_app_level_list))
 353
 354 extern struct grub_net_card *grub_net_cards;
 355
 356 static inline void
 357 grub_net_card_register (struct grub_net_card *card)
 358 {
 359   grub_list_push (GRUB_AS_LIST_P (&grub_net_cards),
 360                   GRUB_AS_LIST (card));
 361 }
 362
 363 void
 364 grub_net_card_unregister (struct grub_net_card *card);
 365
 366 #define FOR_NET_CARDS(var) for (var = grub_net_cards; var; var = var->next)
 367 #define FOR_NET_CARDS_SAFE(var, next) for (var = grub_net_cards, next = (var ? var->next : 0); var; var = next, next = (var ? var->next : 0))
 368
 369
 370 struct grub_net_session *
 371 grub_net_open_tcp (char *address, grub_uint16_t port);
 372
 373 grub_err_t
 374 grub_net_resolve_address (const char *name,
 375                           grub_net_network_level_address_t *addr);
 376
 377 grub_err_t
 378 grub_net_resolve_net_address (const char *name,
 379                               grub_net_network_level_netaddress_t *addr);
 380
 381 grub_err_t
 382 grub_net_route_address (grub_net_network_level_address_t addr,
 383                         grub_net_network_level_address_t *gateway,
 384                         struct grub_net_network_level_interface **interf);
 385
 386
 387 grub_err_t
 388 grub_net_add_route (const char *name,
 389                     grub_net_network_level_netaddress_t target,
 390                     struct grub_net_network_level_interface *inter);
 391
 392 grub_err_t
 393 grub_net_add_route_gw (const char *name,
 394                        grub_net_network_level_netaddress_t target,
 395                        grub_net_network_level_address_t gw);
 396
 397
 398 #define GRUB_NET_BOOTP_MAC_ADDR_LEN     16
 399
 400 typedef grub_uint8_t grub_net_bootp_mac_addr_t[GRUB_NET_BOOTP_MAC_ADDR_LEN];
 401
 402 struct grub_net_bootp_packet
 403 {
 404   grub_uint8_t opcode;
 405   grub_uint8_t hw_type;         /* hardware type.  */
 406   grub_uint8_t hw_len;          /* hardware addr len.  */
 407   grub_uint8_t gate_hops;       /* zero it.  */
 408   grub_uint32_t ident;          /* random number chosen by client.  */
 409   grub_uint16_t seconds;        /* seconds since did initial bootstrap.  */
 410   grub_uint16_t flags;
 411   grub_uint32_t client_ip;
 412   grub_uint32_t your_ip;
 413   grub_uint32_t server_ip;
 414   grub_uint32_t gateway_ip;
 415   grub_net_bootp_mac_addr_t mac_addr;
 416   char server_name[64];
 417   char boot_file[128];
 418   grub_uint8_t vendor[0];
 419 } GRUB_PACKED;
 420
 421 #define GRUB_NET_BOOTP_RFC1048_MAGIC_0  0x63
 422 #define GRUB_NET_BOOTP_RFC1048_MAGIC_1  0x82
 423 #define GRUB_NET_BOOTP_RFC1048_MAGIC_2  0x53
 424 #define GRUB_NET_BOOTP_RFC1048_MAGIC_3  0x63
 425
 426 enum
 427   {
 428     GRUB_NET_BOOTP_PAD = 0x00,
 429     GRUB_NET_BOOTP_NETMASK = 0x01,
 430     GRUB_NET_BOOTP_ROUTER = 0x03,
 431     GRUB_NET_BOOTP_DNS = 0x06,
 432     GRUB_NET_BOOTP_HOSTNAME = 0x0c,
 433     GRUB_NET_BOOTP_DOMAIN = 0x0f,
 434     GRUB_NET_BOOTP_ROOT_PATH = 0x11,
 435     GRUB_NET_BOOTP_EXTENSIONS_PATH = 0x12,
 436     GRUB_NET_BOOTP_END = 0xff
 437   };
 438
 439 struct grub_net_network_level_interface *
 440 grub_net_configure_by_dhcp_ack (const char *name,
 441                                 struct grub_net_card *card,
 442                                 grub_net_interface_flags_t flags,
 443                                 const struct grub_net_bootp_packet *bp,
 444                                 grub_size_t size,
 445                                 int is_def, char **device, char **path);
 446
 447 grub_err_t
 448 grub_net_add_ipv4_local (struct grub_net_network_level_interface *inf,
 449                          int mask);
 450
 451 void
 452 grub_net_process_dhcp (struct grub_net_buff *nb,
 453                        struct grub_net_card *card);
 454
 455 int
 456 grub_net_hwaddr_cmp (const grub_net_link_level_address_t *a,
 457                      const grub_net_link_level_address_t *b);
 458 int
 459 grub_net_addr_cmp (const grub_net_network_level_address_t *a,
 460                    const grub_net_network_level_address_t *b);
 461
 462
 463 /*
 464   Currently supported adresses:
 465   IPv4:   XXX.XXX.XXX.XXX
 466   IPv6:   XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX
 467  */
 468 #define GRUB_NET_MAX_STR_ADDR_LEN sizeof ("XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX")
 469
 470 /*
 471   Currently suppoerted adresses:
 472   ethernet:   XX:XX:XX:XX:XX:XX
 473  */
 474
 475 #define GRUB_NET_MAX_STR_HWADDR_LEN (sizeof ("XX:XX:XX:XX:XX:XX"))
 476
 477 void
 478 grub_net_addr_to_str (const grub_net_network_level_address_t *target,
 479                       char *buf);
 480 void
 481 grub_net_hwaddr_to_str (const grub_net_link_level_address_t *addr, char *str);
 482
 483 void
 484 grub_net_poll_cards (unsigned time, int *stop_condition);
 485
 486 void grub_bootp_init (void);
 487 void grub_bootp_fini (void);
 488
 489 void grub_dns_init (void);
 490 void grub_dns_fini (void);
 491
 492 static inline void
 493 grub_net_network_level_interface_unregister (struct grub_net_network_level_interface *inter)
 494 {
 495   inter->card->num_ifaces--;
 496   *inter->prev = inter->next;
 497   if (inter->next)
 498     inter->next->prev = inter->prev;
 499   inter->next = 0;
 500   inter->prev = 0;
 501 }
 502
 503 void
 504 grub_net_tcp_retransmit (void);
 505
 506 void
 507 grub_net_link_layer_add_address (struct grub_net_card *card,
 508                                  const grub_net_network_level_address_t *nl,
 509                                  const grub_net_link_level_address_t *ll,
 510                                  int override);
 511 int
 512 grub_net_link_layer_resolve_check (struct grub_net_network_level_interface *inf,
 513                                    const grub_net_network_level_address_t *proto_addr);
 514 grub_err_t
 515 grub_net_link_layer_resolve (struct grub_net_network_level_interface *inf,
 516                              const grub_net_network_level_address_t *proto_addr,
 517                              grub_net_link_level_address_t *hw_addr);
 518 grub_err_t
 519 grub_net_dns_lookup (const char *name,
 520                      const struct grub_net_network_level_address *servers,
 521                      grub_size_t n_servers,
 522                      grub_size_t *naddresses,
 523                      struct grub_net_network_level_address **addresses,
 524                      int cache);
 525 grub_err_t
 526 grub_net_add_dns_server (const struct grub_net_network_level_address *s);
 527 void
 528 grub_net_remove_dns_server (const struct grub_net_network_level_address *s);
 529
 530
 531 extern char *grub_net_default_server;
 532
 533 #define GRUB_NET_TRIES 40
 534 #define GRUB_NET_INTERVAL 400
 535
 536 #endif /* ! GRUB_NET_HEADER */