Kill off hotplug.h and just make net devices normal reference-counted
[people/sha0/gpxe.git] / src / include / gpxe / dhcp.h
1 #ifndef _GPXE_DHCP_H
2 #define _GPXE_DHCP_H
3
4 /** @file
5  *
6  * Dynamic Host Configuration Protocol
7  *
8  */
9
10 #include <stdint.h>
11 #include <gpxe/list.h>
12 #include <gpxe/in.h>
13 #include <gpxe/udp.h>
14 #include <gpxe/async.h>
15 #include <gpxe/retry.h>
16
17 /** BOOTP/DHCP server port */
18 #define BOOTPS_PORT 67
19
20 /** BOOTP/DHCP client port */
21 #define BOOTPC_PORT 68
22
23 /** Construct a tag value for an encapsulated option
24  *
25  * This tag value can be passed to Etherboot functions when searching
26  * for DHCP options in order to search for a tag within an
27  * encapsulated options block.
28  */
29 #define DHCP_ENCAP_OPT( encapsulator, encapsulated ) \
30         ( ( (encapsulator) << 8 ) | (encapsulated) )
31 /** Extract encapsulating option block tag from encapsulated tag value */
32 #define DHCP_ENCAPSULATOR( encap_opt ) ( (encap_opt) >> 8 )
33 /** Extract encapsulated option tag from encapsulated tag value */
34 #define DHCP_ENCAPSULATED( encap_opt ) ( (encap_opt) & 0xff )
35 /** Option is encapsulated */
36 #define DHCP_IS_ENCAP_OPT( opt ) DHCP_ENCAPSULATOR( opt )
37
38 /**
39  * @defgroup dhcpopts DHCP option tags
40  * @{
41  */
42
43 /** Padding
44  *
45  * This tag does not have a length field; it is always only a single
46  * byte in length.
47  */
48 #define DHCP_PAD 0
49
50 /** Minimum normal DHCP option */
51 #define DHCP_MIN_OPTION 1
52
53 /** Subnet mask */
54 #define DHCP_SUBNET_MASK 1
55
56 /** Routers */
57 #define DHCP_ROUTERS 3
58
59 /** DNS servers */
60 #define DHCP_DNS_SERVERS 6
61
62 /** Syslog servers */
63 #define DHCP_LOG_SERVERS 7
64
65 /** Host name */
66 #define DHCP_HOST_NAME 12
67
68 /** Domain name */
69 #define DHCP_DOMAIN_NAME 15
70
71 /** Root path */
72 #define DHCP_ROOT_PATH 17
73
74 /** Vendor encapsulated options */
75 #define DHCP_VENDOR_ENCAP 43
76
77 /** Requested IP address */
78 #define DHCP_REQUESTED_ADDRESS 50
79
80 /** Lease time */
81 #define DHCP_LEASE_TIME 51
82
83 /** Option overloading
84  *
85  * The value of this option is the bitwise-OR of zero or more
86  * DHCP_OPTION_OVERLOAD_XXX constants.
87  */
88 #define DHCP_OPTION_OVERLOAD 52
89
90 /** The "file" field is overloaded to contain extra DHCP options */
91 #define DHCP_OPTION_OVERLOAD_FILE 1
92
93 /** The "sname" field is overloaded to contain extra DHCP options */
94 #define DHCP_OPTION_OVERLOAD_SNAME 2
95
96 /** DHCP message type */
97 #define DHCP_MESSAGE_TYPE 53
98 #define DHCPDISCOVER 1
99 #define DHCPOFFER 2
100 #define DHCPREQUEST 3
101 #define DHCPDECLINE 4
102 #define DHCPACK 5
103 #define DHCPNAK 6
104 #define DHCPRELEASE 7
105 #define DHCPINFORM 8
106
107 /** DHCP server identifier */
108 #define DHCP_SERVER_IDENTIFIER 54
109
110 /** Parameter request list */
111 #define DHCP_PARAMETER_REQUEST_LIST 55
112
113 /** Maximum DHCP message size */
114 #define DHCP_MAX_MESSAGE_SIZE 57
115
116 /** Vendor class identifier */
117 #define DHCP_VENDOR_CLASS_ID 60
118
119 /** Client identifier */
120 #define DHCP_CLIENT_ID 61
121
122 /** TFTP server name
123  *
124  * This option replaces the fixed "sname" field, when that field is
125  * used to contain overloaded options.
126  */
127 #define DHCP_TFTP_SERVER_NAME 66
128
129 /** Bootfile name
130  *
131  * This option replaces the fixed "file" field, when that field is
132  * used to contain overloaded options.
133  */
134 #define DHCP_BOOTFILE_NAME 67
135
136 /** Etherboot-specific encapsulated options
137  *
138  * This encapsulated options field is used to contain all options
139  * specific to Etherboot (i.e. not assigned by IANA or other standards
140  * bodies).
141  */
142 #define DHCP_EB_ENCAP 175
143
144 /** Priority of this options block
145  *
146  * This is a signed 8-bit integer field indicating the priority of
147  * this block of options.  It can be used to specify the relative
148  * priority of multiple option blocks (e.g. options from non-volatile
149  * storage versus options from a DHCP server).
150  */
151 #define DHCP_EB_PRIORITY DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 1 )
152
153 /** "Your" IP address
154  *
155  * This option is used internally to contain the value of the "yiaddr"
156  * field, in order to provide a consistent approach to storing and
157  * processing options.  It should never be present in a DHCP packet.
158  */
159 #define DHCP_EB_YIADDR DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 2 )
160
161 /** "Server" IP address
162  *
163  * This option is used internally to contain the value of the "siaddr"
164  * field, in order to provide a consistent approach to storing and
165  * processing options.  It should never be present in a DHCP packet.
166  */
167 #define DHCP_EB_SIADDR DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 3 )
168
169 /** BIOS drive number
170  *
171  * This is the drive number for a drive emulated via INT 13.  0x80 is
172  * the first hard disk, 0x81 is the second hard disk, etc.
173  */
174 #define DHCP_EB_BIOS_DRIVE DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xbd )
175
176 /** Username
177  *
178  * This will be used as the username for any required authentication.
179  * It is expected that this option's value will be held in
180  * non-volatile storage, rather than transmitted as part of a DHCP
181  * packet.
182  */
183 #define DHCP_EB_USERNAME DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xbe )
184
185 /** Password
186  *
187  * This will be used as the password for any required authentication.
188  * It is expected that this option's value will be held in
189  * non-volatile storage, rather than transmitted as part of a DHCP
190  * packet.
191  */
192 #define DHCP_EB_PASSWORD DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xbf )
193
194 /** iSCSI primary target IQN */
195 #define DHCP_ISCSI_PRIMARY_TARGET_IQN 201
196
197 /** iSCSI secondary target IQN */
198 #define DHCP_ISCSI_SECONDARY_TARGET_IQN 202
199
200 /** iSCSI initiator IQN */
201 #define DHCP_ISCSI_INITIATOR_IQN 203
202
203 /** Maximum normal DHCP option */
204 #define DHCP_MAX_OPTION 254
205
206 /** End of options
207  *
208  * This tag does not have a length field; it is always only a single
209  * byte in length.
210  */
211 #define DHCP_END 255
212
213 /** @} */
214
215 /**
216  * Count number of arguments to a variadic macro
217  *
218  * This rather neat, non-iterative solution is courtesy of Laurent
219  * Deniau.
220  *
221  */
222 #define _VA_ARG_COUNT(  _1,  _2,  _3,  _4,  _5,  _6,  _7,  _8,          \
223                         _9, _10, _11, _12, _13, _14, _15, _16,          \
224                        _17, _18, _19, _20, _21, _22, _23, _24,          \
225                        _25, _26, _27, _28, _29, _30, _31, _32,          \
226                        _33, _34, _35, _36, _37, _38, _39, _40,          \
227                        _41, _42, _43, _44, _45, _46, _47, _48,          \
228                        _49, _50, _51, _52, _53, _54, _55, _56,          \
229                        _57, _58, _59, _60, _61, _62, _63,   N, ... ) N
230 #define VA_ARG_COUNT( ... )                                             \
231         _VA_ARG_COUNT ( __VA_ARGS__,                                    \
232                         63, 62, 61, 60, 59, 58, 57, 56,                 \
233                         55, 54, 53, 52, 51, 50, 49, 48,                 \
234                         47, 46, 45, 44, 43, 42, 41, 40,                 \
235                         39, 38, 37, 36, 35, 34, 33, 32,                 \
236                         31, 30, 29, 28, 27, 26, 25, 24,                 \
237                         23, 22, 21, 20, 19, 18, 17, 16,                 \
238                         15, 14, 13, 12, 11, 10,  9,  8,                 \
239                          7,  6,  5,  4,  3,  2,  1,  0 )
240
241 /** Construct a DHCP option from a list of bytes */
242 #define DHCP_OPTION( ... ) VA_ARG_COUNT ( __VA_ARGS__ ), __VA_ARGS__
243
244 /** Construct a DHCP option from a list of characters */
245 #define DHCP_STRING( ... ) DHCP_OPTION ( __VA_ARGS__ )
246
247 /** Construct a byte-valued DHCP option */
248 #define DHCP_BYTE( value ) DHCP_OPTION ( value )
249
250 /** Construct a word-valued DHCP option */
251 #define DHCP_WORD( value ) DHCP_OPTION ( ( ( (value) >> 8 ) & 0xff ),   \
252                                          ( ( (value) >> 0  ) & 0xff ) )
253
254 /** Construct a dword-valued DHCP option */
255 #define DHCP_DWORD( value ) DHCP_OPTION ( ( ( (value) >> 24 ) & 0xff ), \
256                                           ( ( (value) >> 16 ) & 0xff ), \
257                                           ( ( (value) >> 8  ) & 0xff ), \
258                                           ( ( (value) >> 0  ) & 0xff ) )
259
260 /** Construct a DHCP encapsulated options field */
261 #define DHCP_ENCAP( ... ) DHCP_OPTION ( __VA_ARGS__, DHCP_END )
262
263 /**
264  * A DHCP option
265  *
266  * DHCP options consist of a mandatory tag, a length field that is
267  * mandatory for all options except @c DHCP_PAD and @c DHCP_END, and a
268  * payload.  
269  */
270 struct dhcp_option {
271         /** Tag
272          *
273          * Must be a @c DHCP_XXX value.
274          */
275         uint8_t tag;
276         /** Length
277          *
278          * This is the length of the data field (i.e. excluding the
279          * tag and length fields).  For the two tags @c DHCP_PAD and
280          * @c DHCP_END, the length field is implicitly zero and is
281          * also missing, i.e. these DHCP options are only a single
282          * byte in length.
283          */
284         uint8_t len;
285         /** Option data
286          *
287          * Interpretation of the content is entirely dependent upon
288          * the tag.  For fields containing a multi-byte integer, the
289          * field is defined to be in network-endian order (unless you
290          * are Intel and feel like violating the spec for fun).
291          */
292         union {
293                 uint8_t byte;
294                 uint16_t word;
295                 uint32_t dword;
296                 struct in_addr in;
297                 uint8_t bytes[0];
298                 char string[0];
299         } data;
300 } __attribute__ (( packed ));
301
302 /**
303  * Length of a DHCP option header
304  *
305  * The header is the portion excluding the data, i.e. the tag and the
306  * length.
307  */
308 #define DHCP_OPTION_HEADER_LEN ( offsetof ( struct dhcp_option, data ) )
309
310 /** Maximum length for a single DHCP option */
311 #define DHCP_MAX_LEN 0xff
312
313 /** A DHCP options block */
314 struct dhcp_option_block {
315         /** List of option blocks */
316         struct list_head list;
317         /** Option block raw data */
318         void *data;
319         /** Option block length */
320         size_t len;
321         /** Option block maximum length */
322         size_t max_len;
323         /** Block priority
324          *
325          * This is determined at the time of the call to
326          * register_options() by searching for the @c DHCP_EB_PRIORITY
327          * option.
328          */
329         signed int priority;
330 };
331
332 /**
333  * A DHCP header
334  *
335  */
336 struct dhcphdr {
337         /** Operation
338          *
339          * This must be either @c BOOTP_REQUEST or @c BOOTP_REPLY.
340          */
341         uint8_t op;
342         /** Hardware address type
343          *
344          * This is an ARPHRD_XXX constant.  Note that ARPHRD_XXX
345          * constants are nominally 16 bits wide; this could be
346          * considered to be a bug in the BOOTP/DHCP specification.
347          */
348         uint8_t htype;
349         /** Hardware address length */
350         uint8_t hlen;
351         /** Number of hops from server */
352         uint8_t hops;
353         /** Transaction ID */
354         uint32_t xid;
355         /** Seconds since start of acquisition */
356         uint16_t secs;
357         /** Flags */
358         uint16_t flags;
359         /** "Client" IP address
360          *
361          * This is filled in if the client already has an IP address
362          * assigned and can respond to ARP requests.
363          */
364         struct in_addr ciaddr;
365         /** "Your" IP address
366          *
367          * This is the IP address assigned by the server to the client.
368          */
369         struct in_addr yiaddr;
370         /** "Server" IP address
371          *
372          * This is the IP address of the next server to be used in the
373          * boot process.
374          */
375         struct in_addr siaddr;
376         /** "Gateway" IP address
377          *
378          * This is the IP address of the DHCP relay agent, if any.
379          */
380         struct in_addr giaddr;
381         /** Client hardware address */
382         uint8_t chaddr[16];
383         /** Server host name (null terminated)
384          *
385          * This field may be overridden and contain DHCP options
386          */
387         uint8_t sname[64];
388         /** Boot file name (null terminated)
389          *
390          * This field may be overridden and contain DHCP options
391          */
392         uint8_t file[128];
393         /** DHCP magic cookie
394          *
395          * Must have the value @c DHCP_MAGIC_COOKIE.
396          */
397         uint32_t magic;
398         /** DHCP options
399          *
400          * Variable length; extends to the end of the packet.  Minimum
401          * length (for the sake of sanity) is 1, to allow for a single
402          * @c DHCP_END tag.
403          */
404         uint8_t options[1];
405 };
406
407 /** Opcode for a request from client to server */
408 #define BOOTP_REQUEST 1
409
410 /** Opcode for a reply from server to client */
411 #define BOOTP_REPLY 2
412
413 /** DHCP magic cookie */
414 #define DHCP_MAGIC_COOKIE 0x63825363UL
415
416 /** DHCP packet option block fill order
417  *
418  * This is the order in which option blocks are filled when
419  * reassembling a DHCP packet.  We fill the smallest field ("sname")
420  * first, to maximise the chances of being able to fit large options
421  * within fields which are large enough to contain them.
422  */
423 enum dhcp_packet_option_block_fill_order {
424         OPTS_SNAME = 0,
425         OPTS_FILE,
426         OPTS_MAIN,
427         NUM_OPT_BLOCKS
428 };
429
430 /**
431  * A DHCP packet
432  *
433  */
434 struct dhcp_packet {
435         /** The DHCP packet contents */
436         struct dhcphdr *dhcphdr;
437         /** Maximum length of the DHCP packet buffer */
438         size_t max_len;
439         /** Used length of the DHCP packet buffer */
440         size_t len;
441         /** DHCP option blocks within a DHCP packet
442          *
443          * A DHCP packet contains three fields which can be used to
444          * contain options: the actual "options" field plus the "file"
445          * and "sname" fields (which can be overloaded to contain
446          * options).
447          */
448         struct dhcp_option_block options[NUM_OPT_BLOCKS];
449 };
450
451 struct udp_connection {};
452
453 /** A DHCP session */
454 struct dhcp_session {
455         /** UDP connection for this session */
456         struct udp_connection udp;
457
458         /** Network device being configured */
459         struct net_device *netdev;
460
461         /** Options obtained from server */
462         struct dhcp_option_block *options;
463
464         /** State of the session
465          *
466          * This is a value for the @c DHCP_MESSAGE_TYPE option
467          * (e.g. @c DHCPDISCOVER).
468          */
469         int state;
470         /** Asynchronous operation for this DHCP session */
471         struct async async;
472         /** Retransmission timer */
473         struct retry_timer timer;
474 };
475
476 extern unsigned long dhcp_num_option ( struct dhcp_option *option );
477 extern void dhcp_ipv4_option ( struct dhcp_option *option,
478                                struct in_addr *inp );
479 extern int dhcp_snprintf ( char *buf, size_t size,
480                            struct dhcp_option *option );
481 extern struct dhcp_option *
482 find_dhcp_option ( struct dhcp_option_block *options, unsigned int tag );
483 extern void register_dhcp_options ( struct dhcp_option_block *options );
484 extern void unregister_dhcp_options ( struct dhcp_option_block *options );
485 extern void init_dhcp_options ( struct dhcp_option_block *options,
486                                 void *data, size_t max_len );
487 extern struct dhcp_option_block * alloc_dhcp_options ( size_t max_len );
488 extern void free_dhcp_options ( struct dhcp_option_block *options );
489 extern struct dhcp_option *
490 set_dhcp_option ( struct dhcp_option_block *options, unsigned int tag,
491                   const void *data, size_t len );
492 extern struct dhcp_option * find_global_dhcp_option ( unsigned int tag );
493 extern unsigned long find_dhcp_num_option ( struct dhcp_option_block *options,
494                                             unsigned int tag );
495 extern unsigned long find_global_dhcp_num_option ( unsigned int tag );
496 extern void find_dhcp_ipv4_option ( struct dhcp_option_block *options,
497                                     unsigned int tag, struct in_addr *inp );
498 extern void find_global_dhcp_ipv4_option ( unsigned int tag,
499                                            struct in_addr *inp );
500 extern void delete_dhcp_option ( struct dhcp_option_block *options,
501                                  unsigned int tag );
502
503 extern struct dhcp_option_block dhcp_request_options;
504 extern int create_dhcp_packet ( struct net_device *netdev, uint8_t msgtype,
505                                 void *data, size_t max_len,
506                                 struct dhcp_packet *dhcppkt );
507 extern int copy_dhcp_packet_options ( struct dhcp_packet *dhcppkt,
508                                       struct dhcp_option_block *options );
509 extern int start_dhcp ( struct dhcp_session *dhcp, struct async *parent );
510
511 #endif /* _GPXE_DHCP_H */