ReactOS 0.4.16-dev-1163-gec5b142
dhcpd.h File Reference
#include <winsock2.h>
#include <iphlpapi.h>
#include "stdint.h"
#include <pshpack1.h>
#include <poppack.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "dhcp.h"
#include "tree.h"
Include dependency graph for dhcpd.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  ether_header
 
struct  ip
 
struct  udphdr
 
struct  option_data
 
struct  string_list
 
struct  iaddr
 
struct  iaddrlist
 
struct  packet
 
struct  hardware
 
struct  client_lease
 
struct  client_config
 
struct  client_state
 
struct  interface_info
 
struct  timeout
 
struct  protocol
 
struct  hash_bucket
 
struct  hash_table
 

Macros

#define IFNAMSIZ   MAX_INTERFACE_NAME_LEN
 
#define ETH_ALEN   6
 
#define ETHER_ADDR_LEN   ETH_ALEN
 
#define IP_RF   0x8000 /* reserved fragment flag */
 
#define IP_DF   0x4000 /* dont fragment flag */
 
#define IP_MF   0x2000 /* more fragments flag */
 
#define IP_OFFMASK   0x1fff /* mask for fragmenting bits */
 
#define ETHERTYPE_IP   0x0800
 
#define IPTOS_LOWDELAY   0x10
 
#define ARPHRD_ETHER   1
 
#define SIZE_T_MAX   1600
 
#define USE_SOCKET_RECEIVE
 
#define USE_SOCKET_SEND
 
#define LOCAL_PORT   68
 
#define REMOTE_PORT   67
 
#define DEFAULT_HASH_SIZE   97
 
#define _PATH_DHCLIENT_CONF   "/etc/dhclient.conf"
 
#define _PATH_DHCLIENT_DB   "/var/db/dhclient.leases"
 
#define DHCPD_LOG_FACILITY   LOG_DAEMON
 
#define MAX_TIME   0x7fffffff
 
#define MIN_TIME   0
 

Enumerations

enum  dhcp_state {
  S_REBOOTING , S_INIT , S_SELECTING , S_REQUESTING ,
  S_BOUND , S_RENEWING , S_REBINDING , S_STATIC
}
 

Functions

int cons_options (struct packet *, struct dhcp_packet *, int, struct tree_cache **)
 
charpretty_print_option (unsigned int, unsigned char *, int, int, int)
 
void do_packet (struct interface_info *, struct dhcp_packet *, int, unsigned int, struct iaddr, struct hardware *)
 
void error (char *,...) __attribute__((__format__(__printf__
 
void int warning (char *,...) __attribute__((__format__(__printf__
 
void int int note (char *,...) __attribute__((__format__(__printf__
 
void int int int debug (char *,...) __attribute__((__format__(__printf__
 
void int int int int parse_warn (char *,...) __attribute__((__format__(__printf__
 
void new_parse (char *)
 
int next_token (char **, FILE *)
 
int peek_token (char **, FILE *)
 
void skip_to_semi (FILE *)
 
int parse_semi (FILE *)
 
charparse_string (FILE *)
 
int parse_ip_addr (FILE *, struct iaddr *)
 
void parse_hardware_param (FILE *, struct hardware *)
 
void parse_lease_time (FILE *, time_t *)
 
unsigned charparse_numeric_aggregate (FILE *, unsigned char *, int *, int, int, int)
 
void convert_num (unsigned char *, char *, int, int)
 
time_t parse_date (FILE *)
 
pair cons (caddr_t, pair)
 
struct string_listnew_string_list (size_t size)
 
struct hash_tablenew_hash_table (int)
 
struct hash_bucketnew_hash_bucket (void)
 
void dfree (void *, char *)
 
void free_hash_bucket (struct hash_bucket *, char *)
 
int if_register_bpf (struct interface_info *)
 
void if_register_send (struct interface_info *)
 
void if_register_receive (struct interface_info *)
 
ssize_t send_packet (struct interface_info *, struct dhcp_packet *, size_t, struct in_addr, struct sockaddr_in *, struct hardware *)
 
ssize_t receive_packet (struct interface_info *, unsigned char *, size_t, struct sockaddr_in *, struct hardware *)
 
void discover_interfaces (struct interface_info *)
 
void reinitialize_interfaces (void)
 
void dispatch (HANDLE hStopEvent)
 
void got_one (struct protocol *)
 
void add_timeout (time_t, void(*)(void *), void *)
 
void cancel_timeout (void(*)(void *), void *)
 
void add_protocol (char *, int, void(*)(struct protocol *), void *)
 
void remove_protocol (struct protocol *)
 
struct protocolfind_protocol_by_adapter (struct interface_info *)
 
int interface_link_status (char *)
 
struct hash_tablenew_hash (void)
 
void add_hash (struct hash_table *, unsigned char *, int, unsigned char *)
 
unsigned charhash_lookup (struct hash_table *, unsigned char *, int)
 
void initialize_universes (void)
 
u_int32_t getULong (unsigned char *)
 
int32_t getLong (unsigned char *)
 
u_int16_t getUShort (unsigned char *)
 
int16_t getShort (unsigned char *)
 
void putULong (unsigned char *, u_int32_t)
 
void putLong (unsigned char *, int32_t)
 
void putUShort (unsigned char *, unsigned int)
 
void putShort (unsigned char *, int)
 
struct iaddr subnet_number (struct iaddr, struct iaddr)
 
struct iaddr broadcast_addr (struct iaddr, struct iaddr)
 
int addr_eq (struct iaddr, struct iaddr)
 
charpiaddr (struct iaddr)
 
void dhcpoffer (struct packet *)
 
void dhcpack (struct packet *)
 
void dhcpnak (struct packet *)
 
void send_discover (void *)
 
void send_request (void *)
 
void send_decline (void *)
 
void state_reboot (void *)
 
void state_init (void *)
 
void state_selecting (void *)
 
void state_requesting (void *)
 
void state_bound (void *)
 
void state_panic (void *)
 
void bind_lease (struct interface_info *)
 
void make_discover (struct interface_info *, struct client_lease *)
 
void make_request (struct interface_info *, struct client_lease *)
 
void make_decline (struct interface_info *, struct client_lease *)
 
void free_client_lease (struct client_lease *)
 
void rewrite_client_leases (struct interface_info *)
 
void write_client_lease (struct interface_info *, struct client_lease *, int)
 
void priv_script_init (struct interface_info *, char *, char *)
 
void priv_script_write_params (struct interface_info *, char *, struct client_lease *)
 
int priv_script_go (void)
 
void script_init (char *, struct string_list *)
 
void script_write_params (char *, struct client_lease *)
 
int script_go (void)
 
void client_envadd (struct client_state *, const char *, const char *, const char *,...)
 
void script_set_env (struct client_state *, const char *, const char *, const char *)
 
void script_flush_env (struct client_state *)
 
int dhcp_option_ev_name (char *, size_t, struct dhcp_option *)
 
struct client_leasepacket_to_lease (struct packet *)
 
void go_daemon (void)
 
void client_location_changed (void)
 
void bootp (struct packet *)
 
void dhcp (struct packet *)
 
void assemble_hw_header (struct interface_info *, unsigned char *, int *, struct hardware *)
 
void assemble_udp_ip_header (unsigned char *, int *, u_int32_t, u_int32_t, unsigned int, unsigned char *, int)
 
ssize_t decode_hw_header (unsigned char *, int, struct hardware *)
 
ssize_t decode_udp_ip_header (unsigned char *, int, struct sockaddr_in *, unsigned char *, int)
 
void assemble_ethernet_header (struct interface_info *, unsigned char *, int *, struct hardware *)
 
ssize_t decode_ethernet_header (struct interface_info *, unsigned char *, int, struct hardware *)
 
int read_client_conf (struct interface_info *)
 
void read_client_leases (void)
 
void parse_client_statement (FILE *, struct interface_info *, struct client_config *)
 
int parse_X (FILE *, u_int8_t *, int)
 
int parse_option_list (FILE *, u_int8_t *)
 
void parse_interface_declaration (FILE *, struct client_config *)
 
struct interface_infointerface_or_dummy (char *)
 
void make_client_state (struct interface_info *)
 
void make_client_config (struct interface_info *, struct client_config *)
 
void parse_client_lease_statement (FILE *, int)
 
void parse_client_lease_declaration (FILE *, struct client_lease *, struct interface_info **)
 
struct dhcp_optionparse_option_decl (FILE *, struct option_data *)
 
void parse_string_list (FILE *, struct string_list **, int)
 
void parse_reject_statement (FILE *, struct client_config *)
 
struct bufbuf_open (size_t)
 
int buf_add (struct buf *, void *, size_t)
 
int buf_close (int, struct buf *)
 
ssize_t buf_read (int, void *, size_t)
 
void dispatch_imsg (int)
 

Variables

int warnings_occurred
 
void int int int int int lexline
 
void int int int int int lexchar
 
chartoken_line
 
chartlname
 
char comments [4096]
 
int comment_index
 
int eol_token
 
void(* bootp_packet_handler )(struct interface_info *, struct dhcp_packet *, int, unsigned int, struct iaddr, struct hardware *)
 
struct dhcp_option dhcp_options [256]
 
unsigned char dhcp_option_default_priority_list []
 
int sizeof_dhcp_option_default_priority_list
 
struct hash_table universe_hash
 
struct universe dhcp_universe
 
charpath_dhclient_conf
 
charpath_dhclient_db
 
time_t cur_time
 
int log_priority
 
int log_perror
 
struct client_config top_level_config
 

Macro Definition Documentation

◆ _PATH_DHCLIENT_CONF

#define _PATH_DHCLIENT_CONF   "/etc/dhclient.conf"

Definition at line 274 of file dhcpd.h.

◆ _PATH_DHCLIENT_DB

#define _PATH_DHCLIENT_DB   "/var/db/dhclient.leases"

Definition at line 275 of file dhcpd.h.

◆ ARPHRD_ETHER

#define ARPHRD_ETHER   1

Definition at line 88 of file dhcpd.h.

◆ DEFAULT_HASH_SIZE

#define DEFAULT_HASH_SIZE   97

Definition at line 259 of file dhcpd.h.

◆ DHCPD_LOG_FACILITY

#define DHCPD_LOG_FACILITY   LOG_DAEMON

Definition at line 276 of file dhcpd.h.

◆ ETH_ALEN

#define ETH_ALEN   6

Definition at line 50 of file dhcpd.h.

◆ ETHER_ADDR_LEN

#define ETHER_ADDR_LEN   ETH_ALEN

Definition at line 51 of file dhcpd.h.

◆ ETHERTYPE_IP

#define ETHERTYPE_IP   0x0800

Definition at line 86 of file dhcpd.h.

◆ IFNAMSIZ

Definition at line 48 of file dhcpd.h.

◆ IP_DF

#define IP_DF   0x4000 /* dont fragment flag */

Definition at line 70 of file dhcpd.h.

◆ IP_MF

#define IP_MF   0x2000 /* more fragments flag */

Definition at line 71 of file dhcpd.h.

◆ IP_OFFMASK

#define IP_OFFMASK   0x1fff /* mask for fragmenting bits */

Definition at line 72 of file dhcpd.h.

◆ IP_RF

#define IP_RF   0x8000 /* reserved fragment flag */

Definition at line 69 of file dhcpd.h.

◆ IPTOS_LOWDELAY

#define IPTOS_LOWDELAY   0x10

Definition at line 87 of file dhcpd.h.

◆ LOCAL_PORT

#define LOCAL_PORT   68

Definition at line 112 of file dhcpd.h.

◆ MAX_TIME

#define MAX_TIME   0x7fffffff

Definition at line 278 of file dhcpd.h.

◆ MIN_TIME

#define MIN_TIME   0

Definition at line 279 of file dhcpd.h.

◆ REMOTE_PORT

#define REMOTE_PORT   67

Definition at line 113 of file dhcpd.h.

◆ SIZE_T_MAX

#define SIZE_T_MAX   1600

Definition at line 91 of file dhcpd.h.

◆ USE_SOCKET_RECEIVE

#define USE_SOCKET_RECEIVE

Definition at line 93 of file dhcpd.h.

◆ USE_SOCKET_SEND

#define USE_SOCKET_SEND

Definition at line 94 of file dhcpd.h.

Enumeration Type Documentation

◆ dhcp_state

Enumerator
S_REBOOTING 
S_INIT 
S_SELECTING 
S_REQUESTING 
S_BOUND 
S_RENEWING 
S_REBINDING 
S_STATIC 

Definition at line 170 of file dhcpd.h.

170 {
172 S_INIT,
175 S_BOUND,
179};
@ S_REBOOTING
Definition: dhcpd.h:171
@ S_BOUND
Definition: dhcpd.h:175
@ S_RENEWING
Definition: dhcpd.h:176
@ S_REBINDING
Definition: dhcpd.h:177
@ S_SELECTING
Definition: dhcpd.h:173
@ S_REQUESTING
Definition: dhcpd.h:174
@ S_INIT
Definition: dhcpd.h:172
@ S_STATIC
Definition: dhcpd.h:178

Function Documentation

◆ add_hash()

void add_hash ( struct hash_table table,
unsigned char name,
int  len,
unsigned char pointer 
)

Definition at line 82 of file hash.c.

87{
88 int hashno;
89 struct hash_bucket *bp;
90
91 if (!table)
92 return;
93 if (!len)
94 len = strlen ((char *)name);
95
96 hashno = do_hash (name, len, table -> hash_count);
97 bp = new_hash_bucket ();
98
99 if (!bp) {
100 warn ("Can't add %s to hash table.", name);
101 return;
102 }
103 bp -> name = name;
104 bp -> value = pointer;
105 bp -> next = table -> buckets [hashno];
106 bp -> len = len;
107 table -> buckets [hashno] = bp;
108}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
struct hash_bucket * new_hash_bucket(void)
Definition: alloc.c:71
static __inline int do_hash(unsigned char *name, int len, int size)
Definition: hash.c:63
GLsizei const GLvoid * pointer
Definition: glext.h:5848
GLenum GLsizei len
Definition: glext.h:6722
static unsigned __int64 next
Definition: rand_nt.c:6
#define warn(...)
struct list buckets
Definition: threadpool.c:329
unsigned char * name
Definition: dhcpd.h:263
Definition: name.c:39
Definition: pdh_main.c:96

Referenced by assign_file_addresses(), assign_inodes(), compute_linkcount(), and initialize_universes().

◆ add_protocol()

void add_protocol ( char name,
int  fd,
void(*)(struct protocol *)  handler,
void local 
)

Definition at line 342 of file dispatch.c.

344{
345 struct protocol *p;
346
347 p = malloc(sizeof(*p));
348 if (!p)
349 error("can't allocate protocol struct for %s", name);
350
351 p->fd = fd;
352 p->handler = handler;
353 p->local = local;
354 p->next = protocols;
355 protocols = p;
356}
struct protocol * protocols
Definition: dispatch.c:56
#define malloc
Definition: debug_ros.c:4
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7512
#define local
Definition: zutil.h:30
GLfloat GLfloat p
Definition: glext.h:8902
#define error(str)
Definition: mkdosfs.c:1605
static int fd
Definition: io.c:51
struct define * next
Definition: compiler.c:65

Referenced by AdapterDiscoveryThread(), DSAcquireParams(), DSLeaseIpAddress(), and DSRenewIpAddressLease().

◆ add_timeout()

void add_timeout ( time_t  when,
void(*)(void *)  where,
void what 
)

Definition at line 253 of file dispatch.c.

254{
255 struct timeout *t, *q;
256
257 DH_DbgPrint(MID_TRACE,("Adding timeout %x %p %x\n", when, where, what));
258 /* See if this timeout supersedes an existing timeout. */
259 t = NULL;
260 for (q = timeouts; q; q = q->next) {
261 if (q->func == where && q->what == what) {
262 if (t)
263 t->next = q->next;
264 else
265 timeouts = q->next;
266 break;
267 }
268 t = q;
269 }
270
271 /* If we didn't supersede a timeout, allocate a timeout
272 structure now. */
273 if (!q) {
274 if (free_timeouts) {
276 free_timeouts = q->next;
277 q->func = where;
278 q->what = what;
279 } else {
280 q = malloc(sizeof(struct timeout));
281 if (!q) {
282 error("Can't allocate timeout structure!");
283 return;
284 }
285 q->func = where;
286 q->what = what;
287 }
288 }
289
290 q->when = when;
291
292 /* Now sort this timeout into the timeout list. */
293
294 /* Beginning of list? */
295 if (!timeouts || timeouts->when > q->when) {
296 q->next = timeouts;
297 timeouts = q;
298 return;
299 }
300
301 /* Middle of list? */
302 for (t = timeouts; t->next; t = t->next) {
303 if (t->next->when > q->when) {
304 q->next = t->next;
305 t->next = q;
306 return;
307 }
308 }
309
310 /* End of list. */
311 t->next = q;
312 q->next = NULL;
313}
static struct timeout * free_timeouts
Definition: dispatch.c:58
struct timeout * timeouts
Definition: dispatch.c:57
#define MID_TRACE
Definition: debug.h:15
#define DH_DbgPrint(_t_, _x_)
Definition: debug.h:49
#define NULL
Definition: types.h:112
GLdouble GLdouble t
Definition: gl.h:2047
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
Definition: dhcpd.h:245
void * what
Definition: dhcpd.h:249
time_t when
Definition: dhcpd.h:247

Referenced by bind_lease(), dhcpoffer(), send_discover(), and send_request().

◆ addr_eq()

int addr_eq ( struct iaddr  a,
struct iaddr  b 
)

Definition at line 100 of file util.c.

100 {
101 return a.len == b.len && !memcmp( a.iabuf, b.iabuf, a.len );
102}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

Referenced by bootp(), and dhcp().

◆ assemble_ethernet_header()

void assemble_ethernet_header ( struct interface_info ,
unsigned char ,
int ,
struct hardware  
)

◆ assemble_hw_header()

void assemble_hw_header ( struct interface_info ,
unsigned char ,
int ,
struct hardware  
)

◆ assemble_udp_ip_header()

void assemble_udp_ip_header ( unsigned char ,
int ,
u_int32_t  ,
u_int32_t  ,
unsigned int  ,
unsigned char ,
int   
)

◆ bind_lease()

void bind_lease ( struct interface_info ip)

Definition at line 584 of file dhclient.c.

585{
586 PDHCP_ADAPTER Adapter;
587 struct client_lease *new_lease = ip->client->new;
589
590 time(&cur_time);
591
592 /* Remember the medium. */
593 ip->client->new->medium = ip->client->medium;
594
595 /* Replace the old active lease with the new one. */
596 if (ip->client->active)
597 free_client_lease(ip->client->active);
598 ip->client->active = ip->client->new;
599 ip->client->new = NULL;
600
601 /* Set up a timeout to start the renewal process. */
602 /* Timeout of zero means no timeout (some implementations seem to use
603 * one day).
604 */
605 if( ip->client->active->renewal - cur_time )
606 add_timeout(ip->client->active->renewal, state_bound, ip);
607
608 note("bound to %s -- renewal in %ld seconds.",
609 piaddr(ip->client->active->address),
610 (long int)(ip->client->active->renewal - cur_time));
611
612 ip->client->state = S_BOUND;
613
614 Adapter = AdapterFindInfo( ip );
615
616 if( Adapter ) setup_adapter( Adapter, new_lease );
617 else {
618 warning("Could not find adapter for info %p\n", ip);
619 return;
620 }
621 set_name_servers( Adapter, new_lease );
622 set_domain( Adapter, new_lease );
623}
PDHCP_ADAPTER AdapterFindInfo(struct interface_info *ip)
Definition: adapter.c:526
void add_timeout(time_t when, void(*where)(void *), void *what)
Definition: dispatch.c:253
int note(char *format,...)
Definition: util.c:12
char * piaddr(struct iaddr addr)
Definition: util.c:6
void free_client_lease(struct client_lease *lease)
Definition: dhclient.c:1519
void state_bound(void *ipp)
Definition: dhclient.c:632
void setup_adapter(PDHCP_ADAPTER Adapter, struct client_lease *new_lease)
Definition: dhclient.c:492
void set_domain(PDHCP_ADAPTER Adapter, struct client_lease *new_lease)
Definition: dhclient.c:443
void set_name_servers(PDHCP_ADAPTER Adapter, struct client_lease *new_lease)
Definition: dhclient.c:398
time_t cur_time
__kernel_time_t time_t
Definition: linux.h:252
__u16 time
Definition: mkdosfs.c:8
#define warning(s)
Definition: debug.h:83
Definition: dhcpd.h:62

Referenced by dhcpack(), and state_selecting().

◆ bootp()

void bootp ( struct packet packet)

Definition at line 658 of file dhclient.c.

659{
660 struct iaddrlist *ap;
661
662 if (packet->raw->op != BOOTREPLY)
663 return;
664
665 /* If there's a reject list, make sure this packet's sender isn't
666 on it. */
667 for (ap = packet->interface->client->config->reject_list;
668 ap; ap = ap->next) {
669 if (addr_eq(packet->client_addr, ap->addr)) {
670 note("BOOTREPLY from %s rejected.", piaddr(ap->addr));
671 return;
672 }
673 }
675}
int addr_eq(struct iaddr a, struct iaddr b)
Definition: util.c:100
#define BOOTREPLY
Definition: dhcp.h:79
void dhcpoffer(struct packet *packet)
Definition: dhclient.c:714
Definition: dhcpd.h:135
struct dhcp_packet * raw
Definition: dhcpd.h:136
struct interface_info * interface
Definition: dhcpd.h:142
struct iaddr client_addr
Definition: dhcpd.h:141
void int int ULONGLONG int va_list * ap
Definition: winesup.h:36

Referenced by do_packet().

◆ broadcast_addr()

struct iaddr broadcast_addr ( struct iaddr  addr,
struct iaddr  mask 
)

Definition at line 167 of file util.c.

167 {
168 struct iaddr bcast = { 0 };
169 return bcast;
170}
Definition: dhcpd.h:125

Referenced by priv_script_write_params().

◆ buf_add()

int buf_add ( struct buf ,
void ,
size_t   
)

◆ buf_close()

int buf_close ( int  ,
struct buf  
)

◆ buf_open()

struct buf * buf_open ( size_t  )

◆ buf_read()

ssize_t buf_read ( int  ,
void ,
size_t   
)

◆ cancel_timeout()

void cancel_timeout ( void(*)(void *)  where,
void what 
)

Definition at line 316 of file dispatch.c.

317{
318 struct timeout *t, *q;
319
320 /* Look for this timeout on the list, and unlink it if we find it. */
321 t = NULL;
322 for (q = timeouts; q; q = q->next) {
323 if (q->func == where && q->what == what) {
324 if (t)
325 t->next = q->next;
326 else
327 timeouts = q->next;
328 break;
329 }
330 t = q;
331 }
332
333 /* If we found the timeout, put it on the free list. */
334 if (q) {
335 q->next = free_timeouts;
337 }
338}

Referenced by dhcpack(), dhcpnak(), dhcpoffer(), send_request(), and state_selecting().

◆ client_envadd()

void client_envadd ( struct client_state ,
const char ,
const char ,
const char ,
  ... 
)

◆ client_location_changed()

void client_location_changed ( void  )

◆ cons()

pair cons ( caddr_t  car,
pair  cdr 
)

Definition at line 57 of file tree.c.

60{
61 pair foo = (pair)dmalloc (sizeof *foo, "cons");
62 if (!foo)
63 error ("no memory for cons.");
64 foo -> car = car;
65 foo -> cdr = cdr;
66 return foo;
67}
void * dmalloc(int size, char *name)
Definition: util.c:104
Definition: _pair.h:47

Referenced by xmlParseConditionalSections(), xmlParseContentInternal(), xmlParseExternalSubset(), xmlParseInternalSubset(), and xmlParseStartTag2().

◆ cons_options()

int cons_options ( struct packet inpacket,
struct dhcp_packet outpacket,
int  mms,
struct tree_cache **  options 
)

Definition at line 199 of file options.c.

201{
202 unsigned char priority_list[300], buffer[4096];
203 int priority_len, main_buffer_size, mainbufix;
204 int option_size, length;
205
206 /*
207 * If the client has provided a maximum DHCP message size, use
208 * that; otherwise, if it's BOOTP, only 64 bytes; otherwise use
209 * up to the minimum IP MTU size (576 bytes).
210 *
211 * XXX if a BOOTP client specifies a max message size, we will
212 * honor it.
213 */
214 if (!mms &&
215 inpacket &&
216 inpacket->options[DHO_DHCP_MAX_MESSAGE_SIZE].data &&
217 (inpacket->options[DHO_DHCP_MAX_MESSAGE_SIZE].len >=
218 sizeof(u_int16_t)))
219 mms = getUShort(
220 inpacket->options[DHO_DHCP_MAX_MESSAGE_SIZE].data);
221
222 if (mms)
223 main_buffer_size = mms - DHCP_FIXED_LEN;
224 else
225 main_buffer_size = 576 - DHCP_FIXED_LEN;
226
227 if (main_buffer_size > sizeof(buffer))
228 main_buffer_size = sizeof(buffer);
229
230 /* Preload the option priority list with mandatory options. */
231 priority_len = 0;
232 priority_list[priority_len++] = DHO_DHCP_MESSAGE_TYPE;
233 priority_list[priority_len++] = DHO_DHCP_SERVER_IDENTIFIER;
234 priority_list[priority_len++] = DHO_DHCP_LEASE_TIME;
235 priority_list[priority_len++] = DHO_DHCP_MESSAGE;
236
237 /*
238 * If the client has provided a list of options that it wishes
239 * returned, use it to prioritize. Otherwise, prioritize based
240 * on the default priority list.
241 */
242 if (inpacket &&
244 int prlen =
246 if (prlen + priority_len > sizeof(priority_list))
247 prlen = sizeof(priority_list) - priority_len;
248
249 memcpy(&priority_list[priority_len],
251 prlen);
252 priority_len += prlen;
253 } else {
254 memcpy(&priority_list[priority_len],
258 }
259
260 /* Copy the options into the big buffer... */
261 option_size = store_options(
262 buffer,
263 main_buffer_size - 7,
264 options, priority_list, priority_len, main_buffer_size,
265 main_buffer_size);
266
267 /* Put the cookie up front... */
268 memcpy(outpacket->options, DHCP_OPTIONS_COOKIE, 4);
269 mainbufix = 4;
270
271 /*
272 * If we're going to have to overload, store the overload option
273 * at the beginning. If we can, though, just store the whole
274 * thing in the packet's option buffer and leave it at that.
275 */
276 if (option_size <= main_buffer_size - mainbufix) {
277 memcpy(&outpacket->options[mainbufix],
278 buffer, option_size);
279 mainbufix += option_size;
280 if (mainbufix < main_buffer_size)
281 outpacket->options[mainbufix++] = DHO_END;
282 length = DHCP_FIXED_NON_UDP + mainbufix;
283 } else {
284 outpacket->options[mainbufix++] = DHO_DHCP_OPTION_OVERLOAD;
285 outpacket->options[mainbufix++] = 1;
286 if (option_size >
287 main_buffer_size - mainbufix + DHCP_FILE_LEN)
288 outpacket->options[mainbufix++] = 3;
289 else
290 outpacket->options[mainbufix++] = 1;
291
292 memcpy(&outpacket->options[mainbufix],
293 buffer, main_buffer_size - mainbufix);
294 length = DHCP_FIXED_NON_UDP + mainbufix;
295 }
296 return (length);
297}
int store_options(unsigned char *, int, struct tree_cache **, unsigned char *, int, int, int)
Definition: options.c:303
u_int16_t getUShort(unsigned char *data)
Definition: util.c:88
#define DHO_DHCP_MESSAGE
Definition: dhcp.h:152
#define DHO_DHCP_MAX_MESSAGE_SIZE
Definition: dhcp.h:153
#define DHO_DHCP_PARAMETER_REQUEST_LIST
Definition: dhcp.h:151
#define DHCP_FILE_LEN
Definition: dhcp.h:47
#define DHCP_FIXED_NON_UDP
Definition: dhcp.h:48
#define DHO_DHCP_MESSAGE_TYPE
Definition: dhcp.h:149
#define DHCP_OPTIONS_COOKIE
Definition: dhcp.h:91
#define DHO_END
Definition: dhcp.h:159
#define DHO_DHCP_OPTION_OVERLOAD
Definition: dhcp.h:148
#define DHO_DHCP_SERVER_IDENTIFIER
Definition: dhcp.h:150
#define DHO_DHCP_LEASE_TIME
Definition: dhcp.h:147
#define DHCP_FIXED_LEN
Definition: dhcp.h:49
GLuint buffer
Definition: glext.h:5915
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned short u_int16_t
Definition: rosdhcp.h:34
unsigned char options[DHCP_OPTION_LEN]
Definition: dhcp.h:72
struct option_data options[256]
Definition: dhcpd.h:144
int sizeof_dhcp_option_default_priority_list
Definition: tables.c:408
unsigned char dhcp_option_default_priority_list[]
Definition: tables.c:329

Referenced by make_decline(), make_discover(), and make_request().

◆ convert_num()

void convert_num ( unsigned char ,
char ,
int  ,
int   
)

◆ debug()

void int int int debug ( char ,
  ... 
)

◆ decode_ethernet_header()

ssize_t decode_ethernet_header ( struct interface_info ,
unsigned char ,
int  ,
struct hardware  
)

◆ decode_hw_header()

ssize_t decode_hw_header ( unsigned char ,
int  ,
struct hardware  
)

◆ decode_udp_ip_header()

ssize_t decode_udp_ip_header ( unsigned char ,
int  ,
struct sockaddr_in ,
unsigned char ,
int   
)

◆ dfree()

void dfree ( void ptr,
char name 
)

Definition at line 79 of file alloc.c.

80{
81 if (!ptr) {
82 warning("dfree %s: free on null pointer.", name);
83 return;
84 }
85 free(ptr);
86}
#define free
Definition: debug_ros.c:5
static PVOID ptr
Definition: dispmode.c:27

Referenced by do_host_lookup(), free_hash_bucket(), tree_concat(), and tree_evaluate().

◆ dhcp()

void dhcp ( struct packet packet)

Definition at line 678 of file dhclient.c.

679{
680 struct iaddrlist *ap;
681 void (*handler)(struct packet *);
682 char *type;
683
684 switch (packet->packet_type) {
685 case DHCPOFFER:
687 type = "DHCPOFFER";
688 break;
689 case DHCPNAK:
691 type = "DHCPNACK";
692 break;
693 case DHCPACK:
695 type = "DHCPACK";
696 break;
697 default:
698 return;
699 }
700
701 /* If there's a reject list, make sure this packet's sender isn't
702 on it. */
703 for (ap = packet->interface->client->config->reject_list;
704 ap; ap = ap->next) {
705 if (addr_eq(packet->client_addr, ap->addr)) {
706 note("%s from %s rejected.", type, piaddr(ap->addr));
707 return;
708 }
709 }
710 (*handler)(packet);
711}
#define DHCPNAK
Definition: dhcp.h:167
#define DHCPACK
Definition: dhcp.h:166
#define DHCPOFFER
Definition: dhcp.h:163
void dhcpnak(struct packet *packet)
Definition: dhclient.c:919
void dhcpack(struct packet *packet)
Definition: dhclient.c:316
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
int packet_type
Definition: dhcpd.h:138

Referenced by do_packet(), and START_TEST().

◆ dhcp_option_ev_name()

int dhcp_option_ev_name ( char buf,
size_t  buflen,
struct dhcp_option option 
)

Definition at line 1771 of file dhclient.c.

1772{
1773 int i;
1774
1775 for (i = 0; option->name[i]; i++) {
1776 if (i + 1 == buflen)
1777 return 0;
1778 if (option->name[i] == '-')
1779 buf[i] = '_';
1780 else
1781 buf[i] = option->name[i];
1782 }
1783
1784 buf[i] = 0;
1785 return 1;
1786}
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Definition: getopt.h:109
WCHAR * name
Definition: getopt.h:110

Referenced by priv_script_write_params().

◆ dhcpack()

void dhcpack ( struct packet packet)

Definition at line 316 of file dhclient.c.

317{
319 struct client_lease *lease;
321
322 time(&cur_time);
323
324 /* If we're not receptive to an offer right now, or if the offer
325 has an unrecognizable transaction id, then just drop it. */
326 if (packet->interface->client->xid != packet->raw->xid ||
327 (packet->interface->hw_address.hlen != packet->raw->hlen) ||
328 (memcmp(packet->interface->hw_address.haddr,
329 packet->raw->chaddr, packet->raw->hlen)))
330 return;
331
332 if (ip->client->state != S_REBOOTING &&
333 ip->client->state != S_REQUESTING &&
334 ip->client->state != S_RENEWING &&
335 ip->client->state != S_REBINDING)
336 return;
337
338 note("DHCPACK from %s", piaddr(packet->client_addr));
339
340 lease = packet_to_lease(packet);
341 if (!lease) {
342 note("packet_to_lease failed.");
343 return;
344 }
345
346 ip->client->new = lease;
347
348 /* Stop resending DHCPREQUEST. */
350
351 /* Figure out the lease time. */
352 if (ip->client->new->options[DHO_DHCP_LEASE_TIME].data)
353 ip->client->new->expiry = getULong(
354 ip->client->new->options[DHO_DHCP_LEASE_TIME].data);
355 else
356 ip->client->new->expiry = DHCP_DEFAULT_LEASE_TIME;
357 /* A number that looks negative here is really just very large,
358 because the lease expiry offset is unsigned. */
359 if (ip->client->new->expiry < 0)
360 ip->client->new->expiry = TIME_MAX;
361 /* XXX should be fixed by resetting the client state */
362 if (ip->client->new->expiry < 60)
363 ip->client->new->expiry = 60;
364
365 /* Take the server-provided renewal time if there is one;
366 otherwise figure it out according to the spec. */
367 if (ip->client->new->options[DHO_DHCP_RENEWAL_TIME].len)
368 ip->client->new->renewal = getULong(
369 ip->client->new->options[DHO_DHCP_RENEWAL_TIME].data);
370 else
371 ip->client->new->renewal = ip->client->new->expiry / 2;
372
373 /* Same deal with the rebind time. */
374 if (ip->client->new->options[DHO_DHCP_REBINDING_TIME].len)
375 ip->client->new->rebind = getULong(
376 ip->client->new->options[DHO_DHCP_REBINDING_TIME].data);
377 else
378 ip->client->new->rebind = ip->client->new->renewal +
379 ip->client->new->renewal / 2 + ip->client->new->renewal / 4;
380
381#ifdef __REACTOS__
382 ip->client->new->obtained = cur_time;
383#endif
384 ip->client->new->expiry += cur_time;
385 /* Lease lengths can never be negative. */
386 if (ip->client->new->expiry < cur_time)
387 ip->client->new->expiry = TIME_MAX;
388 ip->client->new->renewal += cur_time;
389 if (ip->client->new->renewal < cur_time)
390 ip->client->new->renewal = TIME_MAX;
391 ip->client->new->rebind += cur_time;
392 if (ip->client->new->rebind < cur_time)
393 ip->client->new->rebind = TIME_MAX;
394
395 bind_lease(ip);
396}
void cancel_timeout(void(*where)(void *), void *what)
Definition: dispatch.c:316
u_int32_t getULong(unsigned char *data)
Definition: util.c:96
#define DHO_DHCP_RENEWAL_TIME
Definition: dhcp.h:154
#define DHO_DHCP_REBINDING_TIME
Definition: dhcp.h:155
#define TIME_MAX
Definition: dhclient.c:90
struct client_lease * packet_to_lease(struct packet *packet)
Definition: dhclient.c:833
void bind_lease(struct interface_info *ip)
Definition: dhclient.c:584
#define DHCP_DEFAULT_LEASE_TIME
Definition: rosdhcp.h:30

Referenced by dhcp().

◆ dhcpnak()

void dhcpnak ( struct packet packet)

Definition at line 919 of file dhclient.c.

920{
922
923 /* If we're not receptive to an offer right now, or if the offer
924 has an unrecognizable transaction id, then just drop it. */
925 if (packet->interface->client->xid != packet->raw->xid ||
926 (packet->interface->hw_address.hlen != packet->raw->hlen) ||
927 (memcmp(packet->interface->hw_address.haddr,
928 packet->raw->chaddr, packet->raw->hlen)))
929 return;
930
931 if (ip->client->state != S_REBOOTING &&
932 ip->client->state != S_REQUESTING &&
933 ip->client->state != S_RENEWING &&
934 ip->client->state != S_REBINDING)
935 return;
936
937 note("DHCPNAK from %s", piaddr(packet->client_addr));
938
939 if (!ip->client->active) {
940 note("DHCPNAK with no active lease.\n");
941 return;
942 }
943
944 free_client_lease(ip->client->active);
945 ip->client->active = NULL;
946
947 /* Stop sending DHCPREQUEST packets... */
949
950 ip->client->state = S_INIT;
951 state_init(ip);
952}
void state_init(void *ipp)
Definition: dhclient.c:210

Referenced by dhcp().

◆ dhcpoffer()

void dhcpoffer ( struct packet packet)

Definition at line 714 of file dhclient.c.

715{
717 struct client_lease *lease, *lp;
718 int i;
719 int arp_timeout_needed = 0, stop_selecting;
721 "DHCPOFFER" : "BOOTREPLY";
723
724 time(&cur_time);
725
726 /* If we're not receptive to an offer right now, or if the offer
727 has an unrecognizable transaction id, then just drop it. */
728 if (ip->client->state != S_SELECTING ||
729 packet->interface->client->xid != packet->raw->xid ||
730 (packet->interface->hw_address.hlen != packet->raw->hlen) ||
731 (memcmp(packet->interface->hw_address.haddr,
732 packet->raw->chaddr, packet->raw->hlen)))
733 return;
734
735 note("%s from %s", name, piaddr(packet->client_addr));
736
737
738 /* If this lease doesn't supply the minimum required parameters,
739 blow it off. */
740 for (i = 0; ip->client->config->required_options[i]; i++) {
741 if (!packet->options[ip->client->config->
742 required_options[i]].len) {
743 note("%s isn't satisfactory.", name);
744 return;
745 }
746 }
747
748 /* If we've already seen this lease, don't record it again. */
749 for (lease = ip->client->offered_leases;
750 lease; lease = lease->next) {
751 if (lease->address.len == sizeof(packet->raw->yiaddr) &&
752 !memcmp(lease->address.iabuf,
753 &packet->raw->yiaddr, lease->address.len)) {
754 debug("%s already seen.", name);
755 return;
756 }
757 }
758
759 lease = packet_to_lease(packet);
760 if (!lease) {
761 note("packet_to_lease failed.");
762 return;
763 }
764
765 /* If this lease was acquired through a BOOTREPLY, record that
766 fact. */
768 lease->is_bootp = 1;
769
770 /* Record the medium under which this lease was offered. */
771 lease->medium = ip->client->medium;
772
773 /* Send out an ARP Request for the offered IP address. */
774 if( !check_arp( ip, lease ) ) {
775 note("Arp check failed\n");
776 return;
777 }
778
779 /* Figure out when we're supposed to stop selecting. */
780 stop_selecting =
781 ip->client->first_sending + ip->client->config->select_interval;
782
783 /* If this is the lease we asked for, put it at the head of the
784 list, and don't mess with the arp request timeout. */
785 if (lease->address.len == ip->client->requested_address.len &&
786 !memcmp(lease->address.iabuf,
787 ip->client->requested_address.iabuf,
788 ip->client->requested_address.len)) {
789 lease->next = ip->client->offered_leases;
790 ip->client->offered_leases = lease;
791 } else {
792 /* If we already have an offer, and arping for this
793 offer would take us past the selection timeout,
794 then don't extend the timeout - just hope for the
795 best. */
796 if (ip->client->offered_leases &&
797 (cur_time + arp_timeout_needed) > stop_selecting)
798 arp_timeout_needed = 0;
799
800 /* Put the lease at the end of the list. */
801 lease->next = NULL;
802 if (!ip->client->offered_leases)
803 ip->client->offered_leases = lease;
804 else {
805 for (lp = ip->client->offered_leases; lp->next;
806 lp = lp->next)
807 ; /* nothing */
808 lp->next = lease;
809 }
810 }
811
812 /* If we're supposed to stop selecting before we've had time
813 to wait for the ARPREPLY, add some delay to wait for
814 the ARPREPLY. */
815 if (stop_selecting - cur_time < arp_timeout_needed)
816 stop_selecting = cur_time + arp_timeout_needed;
817
818 /* If the selecting interval has expired, go immediately to
819 state_selecting(). Otherwise, time out into
820 state_selecting at the select interval. */
821 if (stop_selecting <= 0)
823 else {
824 add_timeout(stop_selecting, state_selecting, ip);
826 }
827}
void send_discover(void *ipp)
Definition: dhclient.c:959
void state_selecting(void *ipp)
Definition: dhclient.c:235
int check_arp(struct interface_info *ip, struct client_lease *lp)
Definition: dhclient.c:137
#define debug(msg)
Definition: key_call.c:71
struct string_list * medium
Definition: dhcpd.h:163
struct iaddr address
Definition: dhcpd.h:156
unsigned int is_bootp
Definition: dhcpd.h:165
struct client_lease * next
Definition: dhcpd.h:154

Referenced by bootp(), and dhcp().

◆ discover_interfaces()

void discover_interfaces ( struct interface_info )

◆ dispatch()

void dispatch ( HANDLE  hStopEvent)

Definition at line 70 of file dispatch.c.

71{
72 int count, to_msec;
73 struct protocol *l;
74 time_t howlong, cur_time;
75 HANDLE Events[3];
76 int EventCount = 2;
77
79 Events[1] = hStopEvent;
81
82 ApiLock();
83
84 do {
85 /*
86 * Call any expired timeouts, and then if there's still
87 * a timeout registered, time out the select call then.
88 */
89 time(&cur_time);
90
91 if (timeouts)
92 {
93 struct timeout *t;
94
95 if (timeouts->when <= cur_time) {
96 t = timeouts;
97 timeouts = timeouts->next;
98 (*(t->func))(t->what);
99 t->next = free_timeouts;
101 continue;
102 }
103
104 /*
105 * Figure timeout in milliseconds, and check for
106 * potential overflow, so we can cram into an
107 * int for poll, while not polling with a
108 * negative timeout and blocking indefinitely.
109 */
110 howlong = timeouts->when - cur_time;
111 if (howlong > INT_MAX / 1000)
112 howlong = INT_MAX / 1000;
113 to_msec = howlong * 1000;
114 }
115 else
116 {
117 to_msec = INFINITE;
118 }
119
121 {
122 Events[2] = WSACreateEvent();
123 if (Events[2] != WSA_INVALID_EVENT)
124 {
126 if (count != NO_ERROR)
127 {
130 }
131 else
132 {
133 EventCount = 3;
134 }
135 }
136 }
138 {
141
142 EventCount = 2;
143 }
144
145 ApiUnlock();
146 count = WaitForMultipleObjects(EventCount,
147 Events,
148 FALSE,
149 to_msec);
150 ApiLock();
151 if (count == WAIT_OBJECT_0)
152 {
153 /* Adapter state change */
154 continue;
155 }
156 else if (count == WAIT_OBJECT_0 + 1)
157 {
158 /* Stop event signalled */
159 DPRINT("Dispatch thread stop event!\n");
160 break;
161 }
162 else if (count == WAIT_OBJECT_0 + 2)
163 {
164 /* Packet received */
165
166 /* WSA events are manual reset events */
168 }
169 else
170 {
171 /* Timeout */
172 continue;
173 }
174
175 for (l = protocols; l; l = l->next) {
176 struct interface_info *ip;
177 ip = l->local;
178 if (ip && (l->handler != got_one ||
179 !ip->dead)) {
180 DH_DbgPrint(MID_TRACE,("Handling %x\n", l));
181 (*(l->handler))(l);
182 }
183 }
184 } while (1);
185
187
188 ApiUnlock();
189
190 DPRINT("Dispatch thread stopped!\n");
191}
VOID ApiLock()
Definition: api.c:22
VOID ApiUnlock()
Definition: api.c:26
HANDLE hAdapterStateChangedEvent
Definition: dhcpcsvc.c:20
SOCKET DhcpSocket
Definition: adapter.c:8
void got_one(struct protocol *l)
Definition: dispatch.c:194
HANDLE Events[3]
Definition: schedsvc.c:40
r l[0]
Definition: byte_order.h:168
#define NO_ERROR
Definition: dderror.h:5
HANDLE hStopEvent
Definition: dhcpcsvc.c:19
#define FALSE
Definition: types.h:117
BOOL WSAAPI WSAResetEvent(IN WSAEVENT hEvent)
Definition: event.c:53
BOOL WSAAPI WSACloseEvent(IN WSAEVENT hEvent)
Definition: event.c:23
INT WSAAPI WSAEventSelect(IN SOCKET s, IN WSAEVENT hEventObject, IN LONG lNetworkEvents)
Definition: select.c:182
#define INFINITE
Definition: serial.h:102
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define INT_MAX
Definition: intsafe.h:150
#define DPRINT
Definition: sndvol32.h:73
DWORD WINAPI WaitForMultipleObjects(IN DWORD nCount, IN CONST HANDLE *lpHandles, IN BOOL bWaitAll, IN DWORD dwMilliseconds)
Definition: synch.c:151
#define WAIT_OBJECT_0
Definition: winbase.h:433
WINSOCK_API_LINKAGE WSAEVENT WSAAPI WSACreateEvent(void)
Definition: event.c:42
#define WSA_INVALID_EVENT
Definition: winsock2.h:623
#define FD_READ
Definition: winsock.h:405
#define INVALID_SOCKET
Definition: winsock.h:332
#define FD_CLOSE
Definition: winsock.h:410

Referenced by create_database(), create_list(), create_view(), CxxHandleV8Frame(), database_invoke(), ICreateTypeInfo2_fnSetTypeFlags(), init_test_dispatch(), InstallerImpl_OpenDatabase(), InstallerImpl_OpenPackage(), InstallerImpl_Products(), InstallerImpl_RelatedProducts(), InstallerImpl_SummaryInformation(), main(), run_script(), ServiceMain(), session_invoke(), svc_create(), svc_reg(), svc_tp_create(), test_CreateTypeLib(), test_IConnectionPoint(), test_IWinHttpRequest_Invoke(), test_ParseDisplayName(), test_recinfo(), test_VarCat(), and test_VarUI1FromDisp().

◆ dispatch_imsg()

void dispatch_imsg ( int  )

◆ do_packet()

void do_packet ( struct interface_info interface,
struct dhcp_packet packet,
int  len,
unsigned int  from_port,
struct iaddr  from,
struct hardware hfrom 
)

Definition at line 635 of file options.c.

637{
638 struct packet tp;
639 int i;
640
641 if (packet->hlen > sizeof(packet->chaddr)) {
642 note("Discarding packet with invalid hlen.");
643 return;
644 }
645
646 memset(&tp, 0, sizeof(tp));
647 tp.raw = packet;
648 tp.packet_length = len;
649 tp.client_port = from_port;
650 tp.client_addr = from;
651 tp.interface = interface;
652 tp.haddr = hfrom;
653
655 if (tp.options_valid &&
656 tp.options[DHO_DHCP_MESSAGE_TYPE].data)
657 tp.packet_type = tp.options[DHO_DHCP_MESSAGE_TYPE].data[0];
658 if (tp.packet_type)
659 dhcp(&tp);
660 else
661 bootp(&tp);
662
663 /* Free the data associated with the options. */
664 for (i = 0; i < 256; i++)
665 if (tp.options[i].len && tp.options[i].data)
666 free(tp.options[i].data);
667}
void parse_options(struct packet *)
Definition: options.c:59
#define interface
Definition: basetyps.h:61
void bootp(struct packet *packet)
Definition: dhclient.c:658
void dhcp(struct packet *packet)
Definition: dhclient.c:678
_In_ uint64_t _In_ uint64_t _In_ uint64_t _In_opt_ traverse_ptr * tp
Definition: btrfs.c:2996
#define memset(x, y, z)
Definition: compat.h:39
CardRegion * from
Definition: spigame.cpp:19

Referenced by init_client().

◆ error()

void error ( char format,
  ... 
)

Definition at line 128 of file uimain.c.

818{
819 va_list ap;
820 char text[512];
821 char text1[512];
822
823 sprintf(text1, "ERROR: ");
826 va_end(ap);
827 strcat(text1, text);
828 mi_error(text1);
829}
char * va_list
Definition: acmsvcex.h:78
#define va_end(ap)
Definition: acmsvcex.h:90
#define va_start(ap, A)
Definition: acmsvcex.h:91
const WCHAR * text
Definition: package.c:1794
int __cdecl vsprintf(char *_Dest, const char *_Format, va_list _Args)
Definition: sprintf.c:733
#define sprintf(buf, format,...)
Definition: sprintf.c:55
strcat
Definition: string.h:92
Definition: format.c:58
void mi_error(char *msg)
Definition: win32.c:131

◆ find_protocol_by_adapter()

struct protocol * find_protocol_by_adapter ( struct interface_info info)

Definition at line 412 of file dispatch.c.

413{
414 struct protocol *p;
415
416 for( p = protocols; p; p = p->next ) {
417 if( p->local == (void *)info ) return p;
418 }
419
420 return NULL;
421}

Referenced by AdapterDiscoveryThread(), DSAcquireParams(), DSLeaseIpAddress(), DSReleaseIpAddressLease(), DSReleaseParams(), DSRenewIpAddressLease(), DSStaticRefreshParams(), and IsReconnectHackNeeded().

◆ free_client_lease()

void free_client_lease ( struct client_lease lease)

Definition at line 1519 of file dhclient.c.

1520{
1521 int i;
1522
1523 if (lease->server_name)
1524 free(lease->server_name);
1525 if (lease->filename)
1526 free(lease->filename);
1527 for (i = 0; i < 256; i++) {
1528 if (lease->options[i].len)
1529 free(lease->options[i].data);
1530 }
1531 free(lease);
1532}
struct option_data options[256]
Definition: dhcpd.h:166
char * filename
Definition: dhcpd.h:162
char * server_name
Definition: dhcpd.h:157

Referenced by bind_lease(), dhcpnak(), packet_to_lease(), and state_selecting().

◆ free_hash_bucket()

void free_hash_bucket ( struct hash_bucket ptr,
char name 
)

Definition at line 89 of file alloc.c.

90{
91 dfree(ptr, name);
92}
void dfree(void *ptr, char *name)
Definition: alloc.c:79

Referenced by delete_hash_entry().

◆ getLong()

int32_t getLong ( unsigned char data)

Definition at line 92 of file util.c.

92 {
93 return (int32_t) ntohl(*(u_int32_t*) data);
94}
INT32 int32_t
Definition: types.h:71
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define ntohl(x)
Definition: module.h:205
unsigned int u_int32_t
Definition: rosdhcp.h:35

Referenced by pretty_print_option().

◆ getShort()

int16_t getShort ( unsigned char data)

Definition at line 84 of file util.c.

84 {
85 return (int16_t) ntohs(*(int16_t*) data);
86}
INT16 int16_t
Definition: types.h:70
#define ntohs(x)
Definition: module.h:210

Referenced by pretty_print_option().

◆ getULong()

u_int32_t getULong ( unsigned char data)

Definition at line 96 of file util.c.

96 {
97 return ntohl(*(u_int32_t*)data);
98}

Referenced by dhcpack(), and pretty_print_option().

◆ getUShort()

u_int16_t getUShort ( unsigned char data)

Definition at line 88 of file util.c.

88 {
89 return (u_int16_t) ntohs(*(u_int16_t*) data);
90}

Referenced by cons_options(), and pretty_print_option().

◆ go_daemon()

void go_daemon ( void  )

◆ got_one()

void got_one ( struct protocol l)

Definition at line 194 of file dispatch.c.

195{
196 struct sockaddr_in from;
197 struct hardware hfrom;
198 struct iaddr ifrom;
200 union {
201 /*
202 * Packet input buffer. Must be as large as largest
203 * possible MTU.
204 */
205 unsigned char packbuf[4095];
206 struct dhcp_packet packet;
207 } u;
208 struct interface_info *ip = l->local;
210
211 if ((result = receive_packet(ip, u.packbuf, sizeof(u), &from,
212 &hfrom)) == -1) {
213 warning("receive_packet failed on %s: %d", ip->name,
215 ip->errors++;
216 if (ip->errors > 20) {
217 /* our interface has gone away. */
218 warning("Interface %s no longer appears valid.",
219 ip->name);
220 ip->dead = 1;
221 closesocket(l->fd);
224 if (adapter) {
225 RemoveEntryList(&adapter->ListEntry);
226 free(adapter);
227 }
228 }
229 return;
230 }
231 if (result == 0)
232 return;
233
235 ifrom.len = 4;
236 memcpy(ifrom.iabuf, &from.sin_addr, ifrom.len);
237
238
239 adapter = AdapterFindByHardwareAddress(u.packet.chaddr,
240 u.packet.hlen);
241
242 if (!adapter) {
243 warning("Discarding packet with a non-matching target physical address\n");
244 return;
245 }
246
247 (*bootp_packet_handler)(&adapter->DhclientInfo, &u.packet, result,
248 from.sin_port, ifrom, &hfrom);
249 }
250}
PDHCP_ADAPTER AdapterFindByHardwareAddress(u_int8_t haddr[16], u_int8_t hlen)
Definition: adapter.c:540
void remove_protocol(struct protocol *proto)
Definition: dispatch.c:359
void(* bootp_packet_handler)(struct interface_info *, struct dhcp_packet *, int, unsigned int, struct iaddr, struct hardware *)
Definition: dispatch.c:59
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
return adapter
GLuint64EXT * result
Definition: glext.h:11304
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define closesocket
Definition: ncftp.h:477
int ssize_t
Definition: rosdhcp.h:48
ssize_t receive_packet(struct interface_info *ip, unsigned char *packet_data, size_t packet_len, struct sockaddr_in *dest, struct hardware *hardware)
Definition: socket.c:34
int PASCAL FAR WSAGetLastError(void)
Definition: dllmain.c:131

Referenced by AdapterDiscoveryThread(), dispatch(), DSAcquireParams(), DSLeaseIpAddress(), DSRenewIpAddressLease(), and slurpstring().

◆ hash_lookup()

unsigned char * hash_lookup ( struct hash_table table,
unsigned char name,
int  len 
)

Definition at line 144 of file hash.c.

148{
149 int hashno;
150 struct hash_bucket *bp;
151
152 if (!table)
153 return (unsigned char *)0;
154
155 if (!len)
156 len = strlen ((char *)name);
157
158 hashno = do_hash (name, len, table -> hash_count);
159
160 for (bp = table -> buckets [hashno]; bp; bp = bp -> next) {
161 if (len == bp -> len && !memcmp (bp -> name, name, len))
162 return bp -> value;
163 }
164 return (unsigned char *)0;
165}
unsigned char * value
Definition: dhcpd.h:265

◆ if_register_bpf()

int if_register_bpf ( struct interface_info )

◆ if_register_receive()

void if_register_receive ( struct interface_info ip)

Definition at line 575 of file adapter.c.

575 {
576}

◆ if_register_send()

void if_register_send ( struct interface_info ip)

Definition at line 571 of file adapter.c.

571 {
572
573}

◆ initialize_universes()

void initialize_universes ( void  )

Definition at line 674 of file tables.c.

675{
676 int i;
677
678 dhcp_universe.name = "dhcp";
679 dhcp_universe.hash = new_hash ();
680 if (!dhcp_universe.hash)
681 error ("Can't allocate dhcp option hash table.");
682 for (i = 0; i < 256; i++) {
683 dhcp_universe.options [i] = &dhcp_options [i];
685 (unsigned char *)dhcp_options [i].name, 0,
686 (unsigned char *)&dhcp_options [i]);
687 }
688 universe_hash.hash_count = DEFAULT_HASH_SIZE;
690 (unsigned char *)dhcp_universe.name, 0,
691 (unsigned char *)&dhcp_universe);
692}
void add_hash(struct hash_table *table, unsigned char *name, int len, unsigned char *pointer)
Definition: hash.c:82
struct hash_table * new_hash()
Definition: hash.c:53
#define DEFAULT_HASH_SIZE
Definition: dhcpd.h:259
struct hash_table universe_hash
Definition: tables.c:672
struct universe dhcp_universe
Definition: tables.c:67
struct dhcp_option dhcp_options[256]
Definition: tables.c:68

◆ interface_link_status()

int interface_link_status ( char ifname)

Definition at line 424 of file dispatch.c.

425{
426 return (1);
427}

◆ interface_or_dummy()

struct interface_info * interface_or_dummy ( char )

◆ make_client_config()

void make_client_config ( struct interface_info ,
struct client_config  
)

◆ make_client_state()

void make_client_state ( struct interface_info )

◆ make_decline()

void make_decline ( struct interface_info ip,
struct client_lease lease 
)

Definition at line 1445 of file dhclient.c.

1446{
1447 struct tree_cache *options[256], message_type_tree;
1448 struct tree_cache requested_address_tree;
1449 struct tree_cache server_id_tree, client_id_tree;
1450 unsigned char decline = DHCPDECLINE;
1451 int i;
1452
1453 memset(options, 0, sizeof(options));
1454 memset(&ip->client->packet, 0, sizeof(ip->client->packet));
1455
1456 /* Set DHCP_MESSAGE_TYPE to DHCPDECLINE */
1458 options[i] = &message_type_tree;
1459 options[i]->value = &decline;
1460 options[i]->len = sizeof(decline);
1461 options[i]->buf_size = sizeof(decline);
1462 options[i]->timeout = 0xFFFFFFFF;
1463
1464 /* Send back the server identifier... */
1466 options[i] = &server_id_tree;
1467 options[i]->value = lease->options[i].data;
1468 options[i]->len = lease->options[i].len;
1469 options[i]->buf_size = lease->options[i].len;
1470 options[i]->timeout = 0xFFFFFFFF;
1471
1472 /* Send back the address we're declining. */
1474 options[i] = &requested_address_tree;
1475 options[i]->value = lease->address.iabuf;
1476 options[i]->len = lease->address.len;
1477 options[i]->buf_size = lease->address.len;
1478 options[i]->timeout = 0xFFFFFFFF;
1479
1480 /* Send the uid if the user supplied one. */
1482 if (ip->client->config->send_options[i].len) {
1483 options[i] = &client_id_tree;
1484 options[i]->value = ip->client->config->send_options[i].data;
1485 options[i]->len = ip->client->config->send_options[i].len;
1486 options[i]->buf_size = ip->client->config->send_options[i].len;
1487 options[i]->timeout = 0xFFFFFFFF;
1488 }
1489
1490
1491 /* Set up the option buffer... */
1492 ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
1493 options);
1494 if (ip->client->packet_length < BOOTP_MIN_LEN)
1495 ip->client->packet_length = BOOTP_MIN_LEN;
1496
1497 ip->client->packet.op = BOOTREQUEST;
1498 ip->client->packet.htype = ip->hw_address.htype;
1499 ip->client->packet.hlen = ip->hw_address.hlen;
1500 ip->client->packet.hops = 0;
1501 ip->client->packet.xid = ip->client->xid;
1502 ip->client->packet.secs = 0; /* Filled in by send_request. */
1503 ip->client->packet.flags = 0;
1504
1505 /* ciaddr must always be zero. */
1506 memset(&ip->client->packet.ciaddr, 0,
1507 sizeof(ip->client->packet.ciaddr));
1508 memset(&ip->client->packet.yiaddr, 0,
1509 sizeof(ip->client->packet.yiaddr));
1510 memset(&ip->client->packet.siaddr, 0,
1511 sizeof(ip->client->packet.siaddr));
1512 memset(&ip->client->packet.giaddr, 0,
1513 sizeof(ip->client->packet.giaddr));
1514 memcpy(ip->client->packet.chaddr,
1515 ip->hw_address.haddr, ip->hw_address.hlen);
1516}
int cons_options(struct packet *inpacket, struct dhcp_packet *outpacket, int mms, struct tree_cache **options)
Definition: options.c:199
#define BOOTP_MIN_LEN
Definition: dhcp.h:54
#define DHO_DHCP_CLIENT_IDENTIFIER
Definition: dhcp.h:157
#define BOOTREQUEST
Definition: dhcp.h:78
#define DHO_DHCP_REQUESTED_ADDRESS
Definition: dhcp.h:146
#define DHCPDECLINE
Definition: dhcp.h:165

◆ make_discover()

void make_discover ( struct interface_info ip,
struct client_lease lease 
)

Definition at line 1260 of file dhclient.c.

1261{
1262 unsigned char discover = DHCPDISCOVER;
1263 struct tree_cache *options[256];
1264 struct tree_cache option_elements[256];
1265 int i;
1267
1268 memset(option_elements, 0, sizeof(option_elements));
1269 memset(options, 0, sizeof(options));
1270 memset(&ip->client->packet, 0, sizeof(ip->client->packet));
1271
1272 /* Set DHCP_MESSAGE_TYPE to DHCPDISCOVER */
1274 options[i] = &option_elements[i];
1275 options[i]->value = &discover;
1276 options[i]->len = sizeof(discover);
1277 options[i]->buf_size = sizeof(discover);
1278 options[i]->timeout = 0xFFFFFFFF;
1279
1280 /* Request the options we want */
1282 options[i] = &option_elements[i];
1283 options[i]->value = ip->client->config->requested_options;
1284 options[i]->len = ip->client->config->requested_option_count;
1285 options[i]->buf_size =
1286 ip->client->config->requested_option_count;
1287 options[i]->timeout = 0xFFFFFFFF;
1288
1289 /* If we had an address, try to get it again. */
1290 if (lease) {
1291 ip->client->requested_address = lease->address;
1293 options[i] = &option_elements[i];
1294 options[i]->value = lease->address.iabuf;
1295 options[i]->len = lease->address.len;
1296 options[i]->buf_size = lease->address.len;
1297 options[i]->timeout = 0xFFFFFFFF;
1298 } else
1299 ip->client->requested_address.len = 0;
1300
1301 /* Send any options requested in the config file. */
1302 for (i = 0; i < 256; i++)
1303 if (!options[i] &&
1304 ip->client->config->send_options[i].data) {
1305 options[i] = &option_elements[i];
1306 options[i]->value =
1307 ip->client->config->send_options[i].data;
1308 options[i]->len =
1309 ip->client->config->send_options[i].len;
1310 options[i]->buf_size =
1311 ip->client->config->send_options[i].len;
1312 options[i]->timeout = 0xFFFFFFFF;
1313 }
1314
1315 /* Set up the option buffer... */
1316 ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
1317 options);
1318 if (ip->client->packet_length < BOOTP_MIN_LEN)
1319 ip->client->packet_length = BOOTP_MIN_LEN;
1320
1321 ip->client->packet.op = BOOTREQUEST;
1322 ip->client->packet.htype = ip->hw_address.htype;
1323 ip->client->packet.hlen = ip->hw_address.hlen;
1324 ip->client->packet.hops = 0;
1325 ip->client->packet.xid = RtlRandom(&foo);
1326 ip->client->packet.secs = 0; /* filled in by send_discover. */
1327 ip->client->packet.flags = 0;
1328
1329 memset(&(ip->client->packet.ciaddr),
1330 0, sizeof(ip->client->packet.ciaddr));
1331 memset(&(ip->client->packet.yiaddr),
1332 0, sizeof(ip->client->packet.yiaddr));
1333 memset(&(ip->client->packet.siaddr),
1334 0, sizeof(ip->client->packet.siaddr));
1335 memset(&(ip->client->packet.giaddr),
1336 0, sizeof(ip->client->packet.giaddr));
1337 memcpy(ip->client->packet.chaddr,
1338 ip->hw_address.haddr, ip->hw_address.hlen);
1339}
#define DHCPDISCOVER
Definition: dhcp.h:162
DWORD WINAPI GetTickCount(VOID)
Definition: time.c:455
NTSYSAPI ULONG NTAPI RtlRandom(_Inout_ PULONG Seed)
uint32_t ULONG
Definition: typedefs.h:59

Referenced by state_init().

◆ make_request()

void make_request ( struct interface_info ip,
struct client_lease lease 
)

Definition at line 1343 of file dhclient.c.

1344{
1345 unsigned char request = DHCPREQUEST;
1346 struct tree_cache *options[256];
1347 struct tree_cache option_elements[256];
1348 int i;
1349
1350 memset(options, 0, sizeof(options));
1351 memset(&ip->client->packet, 0, sizeof(ip->client->packet));
1352
1353 /* Set DHCP_MESSAGE_TYPE to DHCPREQUEST */
1355 options[i] = &option_elements[i];
1356 options[i]->value = &request;
1357 options[i]->len = sizeof(request);
1358 options[i]->buf_size = sizeof(request);
1359 options[i]->timeout = 0xFFFFFFFF;
1360
1361 /* Request the options we want */
1363 options[i] = &option_elements[i];
1364 options[i]->value = ip->client->config->requested_options;
1365 options[i]->len = ip->client->config->requested_option_count;
1366 options[i]->buf_size =
1367 ip->client->config->requested_option_count;
1368 options[i]->timeout = 0xFFFFFFFF;
1369
1370 /* If we are requesting an address that hasn't yet been assigned
1371 to us, use the DHCP Requested Address option. */
1372 if (ip->client->state == S_REQUESTING) {
1373 /* Send back the server identifier... */
1375 options[i] = &option_elements[i];
1376 options[i]->value = lease->options[i].data;
1377 options[i]->len = lease->options[i].len;
1378 options[i]->buf_size = lease->options[i].len;
1379 options[i]->timeout = 0xFFFFFFFF;
1380 }
1381 if (ip->client->state == S_REQUESTING ||
1382 ip->client->state == S_REBOOTING) {
1383 ip->client->requested_address = lease->address;
1385 options[i] = &option_elements[i];
1386 options[i]->value = lease->address.iabuf;
1387 options[i]->len = lease->address.len;
1388 options[i]->buf_size = lease->address.len;
1389 options[i]->timeout = 0xFFFFFFFF;
1390 } else
1391 ip->client->requested_address.len = 0;
1392
1393 /* Send any options requested in the config file. */
1394 for (i = 0; i < 256; i++)
1395 if (!options[i] &&
1396 ip->client->config->send_options[i].data) {
1397 options[i] = &option_elements[i];
1398 options[i]->value =
1399 ip->client->config->send_options[i].data;
1400 options[i]->len =
1401 ip->client->config->send_options[i].len;
1402 options[i]->buf_size =
1403 ip->client->config->send_options[i].len;
1404 options[i]->timeout = 0xFFFFFFFF;
1405 }
1406
1407 /* Set up the option buffer... */
1408 ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
1409 options);
1410 if (ip->client->packet_length < BOOTP_MIN_LEN)
1411 ip->client->packet_length = BOOTP_MIN_LEN;
1412
1413 ip->client->packet.op = BOOTREQUEST;
1414 ip->client->packet.htype = ip->hw_address.htype;
1415 ip->client->packet.hlen = ip->hw_address.hlen;
1416 ip->client->packet.hops = 0;
1417 ip->client->packet.xid = ip->client->xid;
1418 ip->client->packet.secs = 0; /* Filled in by send_request. */
1419
1420 /* If we own the address we're requesting, put it in ciaddr;
1421 otherwise set ciaddr to zero. */
1422 if (ip->client->state == S_BOUND ||
1423 ip->client->state == S_RENEWING ||
1424 ip->client->state == S_REBINDING) {
1425 memcpy(&ip->client->packet.ciaddr,
1426 lease->address.iabuf, lease->address.len);
1427 ip->client->packet.flags = 0;
1428 } else {
1429 memset(&ip->client->packet.ciaddr, 0,
1430 sizeof(ip->client->packet.ciaddr));
1431 ip->client->packet.flags = 0;
1432 }
1433
1434 memset(&ip->client->packet.yiaddr, 0,
1435 sizeof(ip->client->packet.yiaddr));
1436 memset(&ip->client->packet.siaddr, 0,
1437 sizeof(ip->client->packet.siaddr));
1438 memset(&ip->client->packet.giaddr, 0,
1439 sizeof(ip->client->packet.giaddr));
1440 memcpy(ip->client->packet.chaddr,
1441 ip->hw_address.haddr, ip->hw_address.hlen);
1442}
#define DHCPREQUEST
Definition: dhcp.h:164
Definition: tftpd.h:86

Referenced by state_bound(), state_reboot(), and state_selecting().

◆ new_hash()

struct hash_table * new_hash ( void  )

Definition at line 53 of file hash.c.

54{
56 if (!rv)
57 return rv;
58 memset (&rv -> buckets [0], 0,
59 DEFAULT_HASH_SIZE * sizeof (struct hash_bucket *));
60 return rv;
61}
struct hash_table * new_hash_table(int count)
Definition: alloc.c:57

Referenced by initialize_universes(), and test_put_hash().

◆ new_hash_bucket()

struct hash_bucket * new_hash_bucket ( void  )

Definition at line 71 of file alloc.c.

72{
73 struct hash_bucket *rval = calloc(1, sizeof(struct hash_bucket));
74
75 return (rval);
76}
float rval
Definition: cylfrac.c:48
#define calloc
Definition: rosglue.h:14

Referenced by add_hash().

◆ new_hash_table()

struct hash_table * new_hash_table ( int  count)

Definition at line 57 of file alloc.c.

58{
59 struct hash_table *rval;
60
61 rval = calloc(1, sizeof(struct hash_table) -
62 (DEFAULT_HASH_SIZE * sizeof(struct hash_bucket *)) +
63 (count * sizeof(struct hash_bucket *)));
64 if (rval == NULL)
65 return (NULL);
66 rval->hash_count = count;
67 return (rval);
68}

Referenced by new_hash().

◆ new_parse()

void new_parse ( char )

◆ new_string_list()

struct string_list * new_string_list ( size_t  size)

Definition at line 46 of file alloc.c.

47{
48 struct string_list *rval;
49
50 rval = calloc(1, sizeof(struct string_list) + size);
51 if (rval != NULL)
52 rval->string = ((char *)rval) + sizeof(struct string_list);
53 return (rval);
54}
GLsizeiptr size
Definition: glext.h:5919

◆ next_token()

int next_token ( char **  ,
FILE  
)

Referenced by get_token(), and wcstok_s().

◆ note()

void int int note ( char ,
  ... 
)

◆ packet_to_lease()

struct client_lease * packet_to_lease ( struct packet packet)

Definition at line 833 of file dhclient.c.

834{
835 struct client_lease *lease;
836 int i;
837
838 lease = malloc(sizeof(struct client_lease));
839
840 if (!lease) {
841 warning("dhcpoffer: no memory to record lease.");
842 return (NULL);
843 }
844
845 memset(lease, 0, sizeof(*lease));
846
847 /* Copy the lease options. */
848 for (i = 0; i < 256; i++) {
849 if (packet->options[i].len) {
850 lease->options[i].data =
851 malloc(packet->options[i].len + 1);
852 if (!lease->options[i].data) {
853 warning("dhcpoffer: no memory for option %d", i);
854 free_client_lease(lease);
855 return (NULL);
856 } else {
857 memcpy(lease->options[i].data,
858 packet->options[i].data,
859 packet->options[i].len);
860 lease->options[i].len =
861 packet->options[i].len;
862 lease->options[i].data[lease->options[i].len] =
863 0;
864 }
865 if (!check_option(lease,i)) {
866 /* ignore a bogus lease offer */
867 warning("Invalid lease option - ignoring offer");
868 free_client_lease(lease);
869 return (NULL);
870 }
871 }
872 }
873
874 lease->address.len = sizeof(packet->raw->yiaddr);
875 memcpy(lease->address.iabuf, &packet->raw->yiaddr, lease->address.len);
876#ifdef __REACTOS__
877 lease->serveraddress.len = sizeof(packet->raw->siaddr);
878 memcpy(lease->serveraddress.iabuf, &packet->raw->siaddr, lease->address.len);
879#endif
880
881 /* If the server name was filled out, copy it. */
883 !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 2)) &&
884 packet->raw->sname[0]) {
885 lease->server_name = malloc(DHCP_SNAME_LEN + 1);
886 if (!lease->server_name) {
887 warning("dhcpoffer: no memory for server name.");
888 free_client_lease(lease);
889 return (NULL);
890 }
891 memcpy(lease->server_name, packet->raw->sname, DHCP_SNAME_LEN);
892 lease->server_name[DHCP_SNAME_LEN]='\0';
893 if (!res_hnok(lease->server_name) ) {
894 warning("Bogus server name %s", lease->server_name );
895 free_client_lease(lease);
896 return (NULL);
897 }
898
899 }
900
901 /* Ditto for the filename. */
903 !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 1)) &&
904 packet->raw->file[0]) {
905 /* Don't count on the NUL terminator. */
906 lease->filename = malloc(DHCP_FILE_LEN + 1);
907 if (!lease->filename) {
908 warning("dhcpoffer: no memory for filename.");
909 free_client_lease(lease);
910 return (NULL);
911 }
912 memcpy(lease->filename, packet->raw->file, DHCP_FILE_LEN);
913 lease->filename[DHCP_FILE_LEN]='\0';
914 }
915 return lease;
916}
#define DHCP_SNAME_LEN
Definition: dhcp.h:46
int check_option(struct client_lease *l, int option)
Definition: dhclient.c:1817
int res_hnok(const char *dn)
Definition: dhclient.c:1912

Referenced by dhcpack(), and dhcpoffer().

◆ parse_client_lease_declaration()

void parse_client_lease_declaration ( FILE ,
struct client_lease ,
struct interface_info **   
)

◆ parse_client_lease_statement()

void parse_client_lease_statement ( FILE ,
int   
)

◆ parse_client_statement()

void parse_client_statement ( FILE ,
struct interface_info ,
struct client_config  
)

◆ parse_date()

time_t parse_date ( FILE )

◆ parse_hardware_param()

void parse_hardware_param ( FILE ,
struct hardware  
)

◆ parse_interface_declaration()

void parse_interface_declaration ( FILE ,
struct client_config  
)

◆ parse_ip_addr()

int parse_ip_addr ( FILE ,
struct iaddr  
)

◆ parse_lease_time()

void parse_lease_time ( FILE ,
time_t  
)

◆ parse_numeric_aggregate()

unsigned char * parse_numeric_aggregate ( FILE ,
unsigned char ,
int ,
int  ,
int  ,
int   
)

◆ parse_option_decl()

struct dhcp_option * parse_option_decl ( FILE ,
struct option_data  
)

◆ parse_option_list()

int parse_option_list ( FILE ,
u_int8_t  
)

◆ parse_reject_statement()

void parse_reject_statement ( FILE ,
struct client_config  
)

◆ parse_semi()

int parse_semi ( FILE )

◆ parse_string()

char * parse_string ( FILE )

◆ parse_string_list()

void parse_string_list ( FILE ,
struct string_list **  ,
int   
)

◆ parse_warn()

void int int int int parse_warn ( char ,
  ... 
)

◆ parse_X()

int parse_X ( FILE ,
u_int8_t ,
int   
)

◆ peek_token()

int peek_token ( char **  ,
FILE  
)

◆ piaddr()

char * piaddr ( struct iaddr  addr)

Definition at line 6 of file util.c.

6 {
7 struct sockaddr_in sa;
8 memcpy(&sa.sin_addr,addr.iabuf,sizeof(sa.sin_addr));
9 return inet_ntoa( sa.sin_addr );
10}
CHAR FAR *WSAAPI inet_ntoa(IN IN_ADDR in)
Definition: addrconv.c:160
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
GLenum const GLvoid * addr
Definition: glext.h:9621

Referenced by bind_lease(), bootp(), dhcp(), dhcpack(), dhcpnak(), dhcpoffer(), priv_script_write_params(), set_name_servers(), setup_adapter(), and write_client_lease().

◆ pretty_print_option()

char * pretty_print_option ( unsigned int  code,
unsigned char data,
int  len,
int  emit_commas,
int  emit_quotes 
)

Definition at line 396 of file options.c.

398{
399 static char optbuf[32768]; /* XXX */
400 int hunksize = 0, numhunk = -1, numelem = 0;
401 char fmtbuf[32], *op = optbuf;
402 int i, j, k, opleft = sizeof(optbuf);
403 unsigned char *dp = data;
404 struct in_addr foo;
405 char comma;
406
407 /* Code should be between 0 and 255. */
408 if (code > 255)
409 error("pretty_print_option: bad code %d", code);
410
411 if (emit_commas)
412 comma = ',';
413 else
414 comma = ' ';
415
416 /* Figure out the size of the data. */
417 for (i = 0; dhcp_options[code].format[i]; i++) {
418 if (!numhunk) {
419 warning("%s: Excess information in format string: %s",
422 break;
423 }
424 numelem++;
425 fmtbuf[i] = dhcp_options[code].format[i];
426 switch (dhcp_options[code].format[i]) {
427 case 'A':
428 --numelem;
429 fmtbuf[i] = 0;
430 numhunk = 0;
431 break;
432 case 'X':
433 for (k = 0; k < len; k++)
434 if (!isascii(data[k]) ||
435 !isprint(data[k]))
436 break;
437 if (k == len) {
438 fmtbuf[i] = 't';
439 numhunk = -2;
440 } else {
441 fmtbuf[i] = 'x';
442 hunksize++;
443 comma = ':';
444 numhunk = 0;
445 }
446 fmtbuf[i + 1] = 0;
447 break;
448 case 't':
449 fmtbuf[i] = 't';
450 fmtbuf[i + 1] = 0;
451 numhunk = -2;
452 break;
453 case 'I':
454 case 'l':
455 case 'L':
456 hunksize += 4;
457 break;
458 case 's':
459 case 'S':
460 hunksize += 2;
461 break;
462 case 'b':
463 case 'B':
464 case 'f':
465 hunksize++;
466 break;
467 case 'e':
468 break;
469 default:
470 warning("%s: garbage in format string: %s",
473 break;
474 }
475 }
476
477 /* Check for too few bytes... */
478 if (hunksize > len) {
479 warning("%s: expecting at least %d bytes; got %d",
480 dhcp_options[code].name, hunksize, len);
481 return ("<error>");
482 }
483 /* Check for too many bytes... */
484 if (numhunk == -1 && hunksize < len)
485 warning("%s: %d extra bytes",
486 dhcp_options[code].name, len - hunksize);
487
488 /* If this is an array, compute its size. */
489 if (!numhunk)
490 numhunk = len / hunksize;
491 /* See if we got an exact number of hunks. */
492 if (numhunk > 0 && numhunk * hunksize < len)
493 warning("%s: %d extra bytes at end of array",
494 dhcp_options[code].name, len - numhunk * hunksize);
495
496 /* A one-hunk array prints the same as a single hunk. */
497 if (numhunk < 0)
498 numhunk = 1;
499
500 /* Cycle through the array (or hunk) printing the data. */
501 for (i = 0; i < numhunk; i++) {
502 for (j = 0; j < numelem; j++) {
503 int opcount;
504 switch (fmtbuf[j]) {
505 case 't':
506 if (emit_quotes) {
507 *op++ = '"';
508 opleft--;
509 }
510 for (; dp < data + len; dp++) {
511 if (!isascii(*dp) ||
512 !isprint(*dp)) {
513 if (dp + 1 != data + len ||
514 *dp != 0) {
515 _snprintf(op, opleft,
516 "\\%03o", *dp);
517 op += 4;
518 opleft -= 4;
519 }
520 } else if (*dp == '"' ||
521 *dp == '\'' ||
522 *dp == '$' ||
523 *dp == '`' ||
524 *dp == '\\') {
525 *op++ = '\\';
526 *op++ = *dp;
527 opleft -= 2;
528 } else {
529 *op++ = *dp;
530 opleft--;
531 }
532 }
533 if (emit_quotes) {
534 *op++ = '"';
535 opleft--;
536 }
537
538 *op = 0;
539 break;
540 case 'I':
541 foo.s_addr = htonl(getULong(dp));
542 strncpy(op, inet_ntoa(foo), opleft - 1);
543 op[opleft - 1] = ANSI_NULL;
544 opcount = strlen(op);
545 if (opcount >= opleft)
546 goto toobig;
547 opleft -= opcount;
548 dp += 4;
549 break;
550 case 'l':
551 opcount = _snprintf(op, opleft, "%ld",
552 (long)getLong(dp));
553 if (opcount >= opleft || opcount == -1)
554 goto toobig;
555 opleft -= opcount;
556 dp += 4;
557 break;
558 case 'L':
559 opcount = _snprintf(op, opleft, "%ld",
560 (unsigned long)getULong(dp));
561 if (opcount >= opleft || opcount == -1)
562 goto toobig;
563 opleft -= opcount;
564 dp += 4;
565 break;
566 case 's':
567 opcount = _snprintf(op, opleft, "%d",
568 getShort(dp));
569 if (opcount >= opleft || opcount == -1)
570 goto toobig;
571 opleft -= opcount;
572 dp += 2;
573 break;
574 case 'S':
575 opcount = _snprintf(op, opleft, "%d",
576 getUShort(dp));
577 if (opcount >= opleft || opcount == -1)
578 goto toobig;
579 opleft -= opcount;
580 dp += 2;
581 break;
582 case 'b':
583 opcount = _snprintf(op, opleft, "%d",
584 *(char *)dp++);
585 if (opcount >= opleft || opcount == -1)
586 goto toobig;
587 opleft -= opcount;
588 break;
589 case 'B':
590 opcount = _snprintf(op, opleft, "%d", *dp++);
591 if (opcount >= opleft || opcount == -1)
592 goto toobig;
593 opleft -= opcount;
594 break;
595 case 'x':
596 opcount = _snprintf(op, opleft, "%x", *dp++);
597 if (opcount >= opleft || opcount == -1)
598 goto toobig;
599 opleft -= opcount;
600 break;
601 case 'f':
602 opcount = (size_t) strncpy(op, *dp++ ? "true" : "false", opleft - 1);
603 op[opleft - 1] = ANSI_NULL;
604 if (opcount >= opleft)
605 goto toobig;
606 opleft -= opcount;
607 break;
608 default:
609 warning("Unexpected format code %c", fmtbuf[j]);
610 }
611 op += strlen(op);
612 opleft -= strlen(op);
613 if (opleft < 1)
614 goto toobig;
615 if (j + 1 < numelem && comma != ':') {
616 *op++ = ' ';
617 opleft--;
618 }
619 }
620 if (i + 1 < numhunk) {
621 *op++ = comma;
622 opleft--;
623 }
624 if (opleft < 1)
625 goto toobig;
626
627 }
628 return (optbuf);
629 toobig:
630 warning("dhcp option too large");
631 return ("<error>");
632}
#define isprint(c)
Definition: acclib.h:73
int32_t getLong(unsigned char *data)
Definition: util.c:92
int16_t getShort(unsigned char *data)
Definition: util.c:84
UINT op
Definition: effect.c:236
__kernel_size_t size_t
Definition: linux.h:237
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define isascii
Definition: ctype.h:742
#define htonl(x)
Definition: module.h:214
int k
Definition: mpi.c:3369
#define ANSI_NULL
strncpy
Definition: string.h:335
Definition: inflate.c:139
Definition: tcpip.h:126
#define _snprintf
Definition: xmlstorage.h:200

Referenced by check_option(), priv_script_write_params(), and write_client_lease().

◆ priv_script_go()

int priv_script_go ( void  )

◆ priv_script_init()

void priv_script_init ( struct interface_info ip,
char reason,
char medium 
)

Definition at line 1625 of file dhclient.c.

1626{
1627 if (ip) {
1628 // XXX Do we need to do anything?
1629 }
1630}

◆ priv_script_write_params()

void priv_script_write_params ( struct interface_info ip,
char prefix,
struct client_lease lease 
)

Definition at line 1633 of file dhclient.c.

1634{
1635 u_int8_t dbuf[1500];
1636 int i, len = 0;
1637
1638#if 0
1639 script_set_env(ip->client, prefix, "ip_address",
1640 piaddr(lease->address));
1641#endif
1642
1643 if (lease->options[DHO_SUBNET_MASK].len &&
1644 (lease->options[DHO_SUBNET_MASK].len <
1645 sizeof(lease->address.iabuf))) {
1646 struct iaddr netmask, subnet, broadcast;
1647
1648 memcpy(netmask.iabuf, lease->options[DHO_SUBNET_MASK].data,
1649 lease->options[DHO_SUBNET_MASK].len);
1650 netmask.len = lease->options[DHO_SUBNET_MASK].len;
1651
1652 subnet = subnet_number(lease->address, netmask);
1653 if (subnet.len) {
1654#if 0
1655 script_set_env(ip->client, prefix, "network_number",
1656 piaddr(subnet));
1657#endif
1658 if (!lease->options[DHO_BROADCAST_ADDRESS].len) {
1659 broadcast = broadcast_addr(subnet, netmask);
1660 if (broadcast.len)
1661#if 0
1662 script_set_env(ip->client, prefix,
1663 "broadcast_address",
1664 piaddr(broadcast));
1665#else
1666 ;
1667#endif
1668 }
1669 }
1670 }
1671
1672#if 0
1673 if (lease->filename)
1674 script_set_env(ip->client, prefix, "filename", lease->filename);
1675 if (lease->server_name)
1676 script_set_env(ip->client, prefix, "server_name",
1677 lease->server_name);
1678#endif
1679
1680 for (i = 0; i < 256; i++) {
1681 u_int8_t *dp = NULL;
1682
1683 if (ip->client->config->defaults[i].len) {
1684 if (lease->options[i].len) {
1685 switch (
1686 ip->client->config->default_actions[i]) {
1687 case ACTION_DEFAULT:
1688 dp = lease->options[i].data;
1689 len = lease->options[i].len;
1690 break;
1691 case ACTION_SUPERSEDE:
1692supersede:
1693 dp = ip->client->
1694 config->defaults[i].data;
1695 len = ip->client->
1696 config->defaults[i].len;
1697 break;
1698 case ACTION_PREPEND:
1699 len = ip->client->
1700 config->defaults[i].len +
1701 lease->options[i].len;
1702 if (len >= sizeof(dbuf)) {
1703 warning("no space to %s %s",
1704 "prepend option",
1706 goto supersede;
1707 }
1708 dp = dbuf;
1709 memcpy(dp,
1710 ip->client->
1711 config->defaults[i].data,
1712 ip->client->
1713 config->defaults[i].len);
1714 memcpy(dp + ip->client->
1715 config->defaults[i].len,
1716 lease->options[i].data,
1717 lease->options[i].len);
1718 dp[len] = '\0';
1719 break;
1720 case ACTION_APPEND:
1721 len = ip->client->
1722 config->defaults[i].len +
1723 lease->options[i].len + 1;
1724 if (len > sizeof(dbuf)) {
1725 warning("no space to %s %s",
1726 "append option",
1728 goto supersede;
1729 }
1730 dp = dbuf;
1731 memcpy(dp,
1732 lease->options[i].data,
1733 lease->options[i].len);
1734 memcpy(dp + lease->options[i].len,
1735 ip->client->
1736 config->defaults[i].data,
1737 ip->client->
1738 config->defaults[i].len);
1739 dp[len-1] = '\0';
1740 }
1741 } else {
1742 dp = ip->client->
1743 config->defaults[i].data;
1744 len = ip->client->
1745 config->defaults[i].len;
1746 }
1747 } else if (lease->options[i].len) {
1748 len = lease->options[i].len;
1749 dp = lease->options[i].data;
1750 } else {
1751 len = 0;
1752 }
1753#if 0
1754 if (len) {
1755 char name[256];
1756
1757 if (dhcp_option_ev_name(name, sizeof(name),
1758 &dhcp_options[i]))
1759 script_set_env(ip->client, prefix, name,
1760 pretty_print_option(i, dp, len, 0, 0));
1761 }
1762#endif
1763 }
1764#if 0
1765 snprintf(tbuf, sizeof(tbuf), "%d", (int)lease->expiry);
1766 script_set_env(ip->client, prefix, "expiry", tbuf);
1767#endif
1768}
char * pretty_print_option(unsigned int code, unsigned char *data, int len, int emit_commas, int emit_quotes)
Definition: options.c:396
struct iaddr broadcast_addr(struct iaddr addr, struct iaddr mask)
Definition: util.c:167
struct iaddr subnet_number(struct iaddr addr, struct iaddr mask)
Definition: util.c:172
#define DHO_BROADCAST_ADDRESS
Definition: dhcp.h:124
#define DHO_SUBNET_MASK
Definition: dhcp.h:97
int dhcp_option_ev_name(char *buf, size_t buflen, struct dhcp_option *option)
Definition: dhclient.c:1771
void script_set_env(struct client_state *, const char *, const char *, const char *)
unsigned char u_int8_t
Definition: rosdhcp.h:33
time_t expiry
Definition: dhcpd.h:155
Character const *const prefix
Definition: tempnam.cpp:195
static const u8_t broadcast[6]
Definition: test_dhcp.c:23
#define snprintf
Definition: wintirpc.h:48

◆ putLong()

void putLong ( unsigned char ,
int32_t   
)

◆ putShort()

void putShort ( unsigned char ,
int   
)

◆ putULong()

void putULong ( unsigned char ,
u_int32_t   
)

◆ putUShort()

void putUShort ( unsigned char ,
unsigned int   
)

◆ read_client_conf()

int read_client_conf ( struct interface_info ifi)

Definition at line 106 of file util.c.

106 {
107 /* What a strange dance */
108 struct client_config *config;
109 char ComputerName [MAX_COMPUTERNAME_LENGTH + 1];
110 LPSTR lpCompName;
111 DWORD ComputerNameSize = sizeof ComputerName / sizeof ComputerName[0];
112
113 if ((ifi!= NULL) && (ifi->client->config != NULL))
114 config = ifi->client->config;
115 else
116 {
117 warn("util.c read_client_conf poorly implemented!");
118 return 0;
119 }
120
121
122 GetComputerName(ComputerName, & ComputerNameSize);
123 debug("Hostname: %s, length: %lu",
124 ComputerName, ComputerNameSize);
125 /* This never gets freed since it's only called once */
126 lpCompName =
127 HeapAlloc(GetProcessHeap(), 0, ComputerNameSize + 1);
128 if (lpCompName !=NULL) {
129 memcpy(lpCompName, ComputerName, ComputerNameSize + 1);
130 /* Send our hostname, some dhcpds use this to update DNS */
131 config->send_options[DHO_HOST_NAME].data = (u_int8_t*)lpCompName;
132 config->send_options[DHO_HOST_NAME].len = ComputerNameSize;
133 debug("Hostname: %s, length: %d",
134 config->send_options[DHO_HOST_NAME].data,
135 config->send_options[DHO_HOST_NAME].len);
136 } else {
137 error("Failed to allocate heap for hostname");
138 }
139 /* Both Linux and Windows send this */
140 config->send_options[DHO_DHCP_CLIENT_IDENTIFIER].data =
141 ifi->hw_address.haddr;
142 config->send_options[DHO_DHCP_CLIENT_IDENTIFIER].len =
143 ifi->hw_address.hlen;
144
145 /* Setup the requested option list */
146 config->requested_options
147 [config->requested_option_count++] = DHO_SUBNET_MASK;
148 config->requested_options
149 [config->requested_option_count++] = DHO_BROADCAST_ADDRESS;
150 config->requested_options
151 [config->requested_option_count++] = DHO_TIME_OFFSET;
152 config->requested_options
153 [config->requested_option_count++] = DHO_ROUTERS;
154 config->requested_options
155 [config->requested_option_count++] = DHO_DOMAIN_NAME;
156 config->requested_options
157 [config->requested_option_count++] = DHO_DOMAIN_NAME_SERVERS;
158 config->requested_options
159 [config->requested_option_count++] = DHO_HOST_NAME;
160 config->requested_options
161 [config->requested_option_count++] = DHO_NTP_SERVERS;
162
163 warn("util.c read_client_conf poorly implemented!");
164 return 0;
165}
#define DHO_NTP_SERVERS
Definition: dhcp.h:138
#define DHO_HOST_NAME
Definition: dhcp.h:108
#define DHO_TIME_OFFSET
Definition: dhcp.h:98
#define DHO_DOMAIN_NAME
Definition: dhcp.h:111
#define DHO_DOMAIN_NAME_SERVERS
Definition: dhcp.h:102
#define DHO_ROUTERS
Definition: dhcp.h:99
struct config_s config
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
unsigned long DWORD
Definition: ntddk_ex.h:95
struct client_state * client
Definition: dhcpd.h:238
struct hardware hw_address
Definition: dhcpd.h:229
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:270
#define GetComputerName
Definition: winbase.h:3832
char * LPSTR
Definition: xmlstorage.h:182

Referenced by AdapterDiscoveryThread().

◆ read_client_leases()

void read_client_leases ( void  )

◆ receive_packet()

ssize_t receive_packet ( struct interface_info ip,
unsigned char packet_data,
size_t  packet_len,
struct sockaddr_in dest,
struct hardware hardware 
)

Definition at line 34 of file socket.c.

38 {
39 int recv_addr_size = sizeof(*dest);
40 int result;
41
42 if (packet_len > INT_MAX)
43 return WSAEMSGSIZE;
44
45 result =
46 recvfrom (ip -> rfdesc, (char *)packet_data, (int)packet_len, 0,
47 (struct sockaddr *)dest, &recv_addr_size );
48 return result;
49}
INT WSAAPI recvfrom(IN SOCKET s, OUT CHAR FAR *buf, IN INT len, IN INT flags, OUT LPSOCKADDR from, IN OUT INT FAR *fromlen)
Definition: recv.c:87
static char * dest
Definition: rtl.c:135
#define WSAEMSGSIZE
Definition: winerror.h:1953

Referenced by got_one().

◆ reinitialize_interfaces()

void reinitialize_interfaces ( void  )

◆ remove_protocol()

void remove_protocol ( struct protocol proto)

Definition at line 359 of file dispatch.c.

360{
361 struct protocol *p, *next, *prev;
362 struct interface_info *ip = proto->local;
363 struct timeout *t, *q, *u;
364
365 t = NULL;
366 q = timeouts;
367 while (q != NULL)
368 {
369 /* Remove all timeouts for this protocol */
370 if (q->what == ip)
371 {
372 /* Unlink the timeout from previous */
373 if (t)
374 t->next = q->next;
375 else
376 timeouts = q->next;
377
378 /* Advance to the next timeout */
379 u = q->next;
380
381 /* Add it to the free list */
382 q->next = free_timeouts;
384 }
385 else
386 {
387 /* Advance to the next timeout */
388 u = q->next;
389
390 /* Update the previous pointer */
391 t = q;
392 }
393
394 /* Advance */
395 q = u;
396 }
397
398 prev = NULL;
399 for (p = protocols; p; p = next) {
400 next = p->next;
401 if (p == proto) {
402 if (prev)
403 prev->next = p->next;
404 else
405 protocols = p->next;
406 free(p);
407 }
408 }
409}
struct protocol * next
Definition: dhcpd.h:253

Referenced by AdapterDiscoveryThread(), DSAcquireParams(), DSLeaseIpAddress(), DSReleaseIpAddressLease(), DSReleaseParams(), DSRenewIpAddressLease(), DSStaticRefreshParams(), and got_one().

◆ rewrite_client_leases()

void rewrite_client_leases ( struct interface_info ifi)

Definition at line 1537 of file dhclient.c.

1538{
1539 struct client_lease *lp;
1540
1541 if (!leaseFile) {
1543 if (!leaseFile)
1544 error("can't create %s", path_dhclient_db);
1545 } else {
1548 }
1549
1550 for (lp = ifi->client->leases; lp; lp = lp->next)
1551 write_client_lease(ifi, lp, 1);
1552 if (ifi->client->active)
1553 write_client_lease(ifi, ifi->client->active, 1);
1554
1556}
char * path_dhclient_db
Definition: dhclient.c:74
void write_client_lease(struct interface_info *ip, struct client_lease *lease, int rewrite)
Definition: dhclient.c:1559
FILE * leaseFile
Definition: dhclient.c:1534
_CRTIMP void __cdecl rewind(_Inout_ FILE *_File)
_Check_return_opt_ _CRTIMP int __cdecl fflush(_Inout_opt_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)

Referenced by write_client_lease().

◆ script_flush_env()

void script_flush_env ( struct client_state )

◆ script_go()

int script_go ( void  )

◆ script_init()

void script_init ( char ,
struct string_list  
)

◆ script_set_env()

void script_set_env ( struct client_state ,
const char ,
const char ,
const char  
)

◆ script_write_params()

void script_write_params ( char ,
struct client_lease  
)

◆ send_decline()

void send_decline ( void ipp)

Definition at line 1246 of file dhclient.c.

1247{
1248 struct interface_info *ip = ipp;
1249
1250 note("DHCPDECLINE on %s to %s port %d", ip->name,
1251 inet_ntoa(sockaddr_broadcast.sin_addr),
1252 ntohs(sockaddr_broadcast.sin_port));
1253
1254 /* Send out a packet. */
1255 (void) send_packet(ip, &ip->client->packet, ip->client->packet_length,
1257}
struct in_addr inaddr_any
Definition: dhclient.c:81
struct sockaddr_in sockaddr_broadcast
Definition: dhclient.c:82
ssize_t send_packet(struct interface_info *ip, struct dhcp_packet *p, size_t size, struct in_addr addr, struct sockaddr_in *broadcast, struct hardware *hardware)
Definition: socket.c:9

◆ send_discover()

void send_discover ( void ipp)

Definition at line 959 of file dhclient.c.

960{
961 struct interface_info *ip = ipp;
962 int interval, increase = 1;
964
965 DH_DbgPrint(MID_TRACE,("Doing discover on interface %p\n",ip));
966
967 time(&cur_time);
968
969 /* Figure out how long it's been since we started transmitting. */
970 interval = cur_time - ip->client->first_sending;
971
972 /* If we're past the panic timeout, call the script and tell it
973 we haven't found anything for this interface yet. */
974 if (interval > ip->client->config->timeout) {
976 ip->client->first_sending = cur_time;
977 }
978
979 /* If we're selecting media, try the whole list before doing
980 the exponential backoff, but if we've already received an
981 offer, stop looping, because we obviously have it right. */
982 if (!ip->client->offered_leases &&
983 ip->client->config->media) {
984 int fail = 0;
985
986 if (ip->client->medium) {
987 ip->client->medium = ip->client->medium->next;
988 increase = 0;
989 }
990 if (!ip->client->medium) {
991 if (fail)
992 error("No valid media types for %s!", ip->name);
993 ip->client->medium = ip->client->config->media;
994 increase = 1;
995 }
996
997 note("Trying medium \"%s\" %d", ip->client->medium->string,
998 increase);
999 /* XXX Support other media types eventually */
1000 }
1001
1002 /*
1003 * If we're supposed to increase the interval, do so. If it's
1004 * currently zero (i.e., we haven't sent any packets yet), set
1005 * it to one; otherwise, add to it a random number between zero
1006 * and two times itself. On average, this means that it will
1007 * double with every transmission.
1008 */
1009 if (increase) {
1010 if (!ip->client->interval)
1011 ip->client->interval =
1012 ip->client->config->initial_interval;
1013 else {
1014 ip->client->interval += (rand() >> 2) %
1015 (2 * ip->client->interval);
1016 }
1017
1018 /* Don't backoff past cutoff. */
1019 if (ip->client->interval >
1020 ip->client->config->backoff_cutoff)
1021 ip->client->interval =
1022 ((ip->client->config->backoff_cutoff / 2)
1023 + ((rand() >> 2) %
1024 ip->client->config->backoff_cutoff));
1025 } else if (!ip->client->interval)
1026 ip->client->interval =
1027 ip->client->config->initial_interval;
1028
1029 /* If the backoff would take us to the panic timeout, just use that
1030 as the interval. */
1031 if (cur_time + ip->client->interval >
1032 ip->client->first_sending + ip->client->config->timeout)
1033 ip->client->interval =
1034 (ip->client->first_sending +
1035 ip->client->config->timeout) - cur_time + 1;
1036
1037 /* Record the number of seconds since we started sending. */
1038 if (interval < 65536)
1039 ip->client->packet.secs = htons(interval);
1040 else
1041 ip->client->packet.secs = htons(65535);
1042 ip->client->secs = ip->client->packet.secs;
1043
1044 note("DHCPDISCOVER on %s to %s port %d interval %ld",
1045 ip->name, inet_ntoa(sockaddr_broadcast.sin_addr),
1046 ntohs(sockaddr_broadcast.sin_port), (long int)ip->client->interval);
1047
1048 /* Send out a packet. */
1049 (void)send_packet(ip, &ip->client->packet, ip->client->packet_length,
1051
1052 DH_DbgPrint(MID_TRACE,("discover timeout: now %x -> then %x\n",
1053 cur_time, cur_time + ip->client->interval));
1054
1055 add_timeout(cur_time + ip->client->interval, send_discover, ip);
1056}
void state_panic(void *ipp)
Definition: dhclient.c:1065
static void increase(int &a_)
_Check_return_ int __cdecl rand(void)
Definition: rand.c:10
#define htons(x)
Definition: module.h:215

Referenced by dhcpoffer(), send_discover(), state_init(), and state_selecting().

◆ send_packet()

ssize_t send_packet ( struct interface_info ip,
struct dhcp_packet p,
size_t  size,
struct in_addr  addr,
struct sockaddr_in broadcast,
struct hardware hardware 
)

Definition at line 9 of file socket.c.

14 {
15 int result;
16
17 if (size > INT_MAX)
18 return WSAEMSGSIZE;
19
20 result =
21 sendto( ip->wfdesc, (char *)p, (int)size, 0,
22 (struct sockaddr *)broadcast, sizeof(*broadcast) );
23
24 if (result < 0) {
25 note ("send_packet: %x", result);
27 note ("send_packet: please consult README file%s",
28 " regarding broadcast address.");
29 }
30
31 return result;
32}
INT WSAAPI sendto(IN SOCKET s, IN CONST CHAR FAR *buf, IN INT len, IN INT flags, IN CONST struct sockaddr *to, IN INT tolen)
Definition: send.c:82
#define WSAENETUNREACH
Definition: winerror.h:1964

Referenced by send_decline(), send_discover(), and send_request().

◆ send_request()

void send_request ( void ipp)

Definition at line 1117 of file dhclient.c.

1118{
1119 struct interface_info *ip = ipp;
1120 struct sockaddr_in destination;
1121 struct in_addr from;
1122 int interval;
1124
1125 time(&cur_time);
1126
1127 /* Figure out how long it's been since we started transmitting. */
1128 interval = cur_time - ip->client->first_sending;
1129
1130 /* If we're in the INIT-REBOOT or REQUESTING state and we're
1131 past the reboot timeout, go to INIT and see if we can
1132 DISCOVER an address... */
1133 /* XXX In the INIT-REBOOT state, if we don't get an ACK, it
1134 means either that we're on a network with no DHCP server,
1135 or that our server is down. In the latter case, assuming
1136 that there is a backup DHCP server, DHCPDISCOVER will get
1137 us a new address, but we could also have successfully
1138 reused our old address. In the former case, we're hosed
1139 anyway. This is not a win-prone situation. */
1140 if ((ip->client->state == S_REBOOTING ||
1141 ip->client->state == S_REQUESTING) &&
1142 interval > ip->client->config->reboot_timeout) {
1143 ip->client->state = S_INIT;
1145 state_init(ip);
1146 return;
1147 }
1148
1149 /* If we're in the reboot state, make sure the media is set up
1150 correctly. */
1151 if (ip->client->state == S_REBOOTING &&
1152 !ip->client->medium &&
1153 ip->client->active->medium ) {
1154 /* If the medium we chose won't fly, go to INIT state. */
1155 /* XXX Nothing for now */
1156
1157 /* Record the medium. */
1158 ip->client->medium = ip->client->active->medium;
1159 }
1160
1161 /* If the lease has expired, relinquish the address and go back
1162 to the INIT state. */
1163 if (ip->client->state != S_REQUESTING &&
1164 cur_time > ip->client->active->expiry) {
1165 PDHCP_ADAPTER Adapter = AdapterFindInfo( ip );
1166 /* Run the client script with the new parameters. */
1167 /* No script actions necessary in the expiry case */
1168 /* Now do a preinit on the interface so that we can
1169 discover a new address. */
1170
1171 if( Adapter )
1172 {
1173 DeleteIPAddress( Adapter->NteContext );
1174 Adapter->NteContext = 0;
1175 }
1176
1177 ip->client->state = S_INIT;
1178 state_init(ip);
1179 return;
1180 }
1181
1182 /* Do the exponential backoff... */
1183 if (!ip->client->interval)
1184 ip->client->interval = ip->client->config->initial_interval;
1185 else
1186 ip->client->interval += ((rand() >> 2) %
1187 (2 * ip->client->interval));
1188
1189 /* Don't backoff past cutoff. */
1190 if (ip->client->interval >
1191 ip->client->config->backoff_cutoff)
1192 ip->client->interval =
1193 ((ip->client->config->backoff_cutoff / 2) +
1194 ((rand() >> 2) % ip->client->interval));
1195
1196 /* If the backoff would take us to the expiry time, just set the
1197 timeout to the expiry time. */
1198 if (ip->client->state != S_REQUESTING &&
1199 cur_time + ip->client->interval >
1200 ip->client->active->expiry)
1201 ip->client->interval =
1202 ip->client->active->expiry - cur_time + 1;
1203
1204 /* If the lease T2 time has elapsed, or if we're not yet bound,
1205 broadcast the DHCPREQUEST rather than unicasting. */
1206 memset(&destination, 0, sizeof(destination));
1207 if (ip->client->state == S_REQUESTING ||
1208 ip->client->state == S_REBOOTING ||
1209 cur_time > ip->client->active->rebind)
1210 destination.sin_addr.s_addr = INADDR_BROADCAST;
1211 else
1212 memcpy(&destination.sin_addr.s_addr,
1213 ip->client->destination.iabuf,
1214 sizeof(destination.sin_addr.s_addr));
1215 destination.sin_port = htons(REMOTE_PORT);
1216 destination.sin_family = AF_INET;
1217// destination.sin_len = sizeof(destination);
1218
1219 if (ip->client->state != S_REQUESTING)
1220 memcpy(&from, ip->client->active->address.iabuf,
1221 sizeof(from));
1222 else
1223 from.s_addr = INADDR_ANY;
1224
1225 /* Record the number of seconds since we started sending. */
1226 if (ip->client->state == S_REQUESTING)
1227 ip->client->packet.secs = ip->client->secs;
1228 else {
1229 if (interval < 65536)
1230 ip->client->packet.secs = htons(interval);
1231 else
1232 ip->client->packet.secs = htons(65535);
1233 }
1234
1235 note("DHCPREQUEST on %s to %s port %d", ip->name,
1236 inet_ntoa(destination.sin_addr), ntohs(destination.sin_port));
1237
1238 /* Send out a packet. */
1239 (void) send_packet(ip, &ip->client->packet, ip->client->packet_length,
1240 from, &destination, NULL);
1241
1242 add_timeout(cur_time + ip->client->interval, send_request, ip);
1243}
#define REMOTE_PORT
Definition: dhcpd.h:113
#define AF_INET
Definition: tcpip.h:117
DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
#define INADDR_BROADCAST
Definition: inet.h:82
#define INADDR_ANY
Definition: inet.h:80
ULONG NteContext
Definition: rosdhcp.h:70

◆ skip_to_semi()

void skip_to_semi ( FILE )

◆ state_bound()

void state_bound ( void ipp)

Definition at line 632 of file dhclient.c.

633{
634 struct interface_info *ip = ipp;
635
637
638 /* T1 has expired. */
639 make_request(ip, ip->client->active);
640 ip->client->xid = ip->client->packet.xid;
641
642 if (ip->client->active->options[DHO_DHCP_SERVER_IDENTIFIER].len == 4) {
643 memcpy(ip->client->destination.iabuf, ip->client->active->
645 ip->client->destination.len = 4;
646 } else
647 ip->client->destination = iaddr_broadcast;
648
649 time(&ip->client->first_sending);
650 ip->client->interval = ip->client->config->initial_interval;
651 ip->client->state = S_RENEWING;
652
653 /* Send the first packet immediately. */
655}
static int state
Definition: maze.c:121
void make_request(struct interface_info *ip, struct client_lease *lease)
Definition: dhclient.c:1343
struct iaddr iaddr_broadcast
Definition: dhclient.c:80
#define ASSERT_STATE(state_is, state_shouldbe)
Definition: dhclient.c:88

Referenced by bind_lease().

◆ state_init()

void state_init ( void ipp)

Definition at line 210 of file dhclient.c.

211{
212 struct interface_info *ip = ipp;
213
215
216 /* Make a DHCPDISCOVER packet, and set appropriate per-interface
217 flags. */
218 make_discover(ip, ip->client->active);
219 ip->client->xid = ip->client->packet.xid;
220 ip->client->destination = iaddr_broadcast;
221 ip->client->state = S_SELECTING;
222 time(&ip->client->first_sending);
223 ip->client->interval = ip->client->config->initial_interval;
224
225 /* Add an immediate timeout to cause the first DHCPDISCOVER packet
226 to go out. */
228}
void make_discover(struct interface_info *ip, struct client_lease *lease)
Definition: dhclient.c:1260

Referenced by AdapterDiscoveryThread(), device_init(), dhcpnak(), send_request(), state_reboot(), state_selecting(), wined3d_cs_create(), wined3d_cs_exec_reset_state(), and wined3d_device_reset().

◆ state_panic()

void state_panic ( void ipp)

Definition at line 1065 of file dhclient.c.

1066{
1067 struct interface_info *ip = ipp;
1068 uint16_t address_low;
1069 int i;
1070 IPAddr IpAddress;
1071 ULONG Buffer[20];
1073 DWORD ret;
1074 PDHCP_ADAPTER Adapter = AdapterFindInfo(ip);
1075
1076 note("No DHCPOFFERS received.");
1077
1078 if (!Adapter->NteContext)
1079 {
1080 /* Generate an automatic private address */
1081 DbgPrint("DHCPCSVC: Failed to receive a response from a DHCP server. An automatic private address will be assigned.\n");
1082
1083 /* FIXME: The address generation code sucks */
1084 srand(0);
1085
1086 for (;;)
1087 {
1088 address_low = rand();
1089 for (i = 0; i < ip->hw_address.hlen; i++)
1090 address_low += ip->hw_address.haddr[i];
1091
1092 IpAddress = htonl(0xA9FE0000 | address_low); // 169.254.X.X
1093
1094 /* Send an ARP request to check if the IP address is already in use */
1095 BufferSize = sizeof(Buffer);
1096 ret = SendARP(IpAddress,
1097 IpAddress,
1098 Buffer,
1099 &BufferSize);
1100 DH_DbgPrint(MID_TRACE,("DHCPCSVC: SendARP returned %lu\n", ret));
1101 if (ret != 0)
1102 {
1103 /* The IP address is not in use */
1104 DH_DbgPrint(MID_TRACE,("DHCPCSVC: Using automatic private address\n"));
1105 AddIPAddress(IpAddress,
1106 htonl(0xFFFF0000), // 255.255.0.0
1107 Adapter->IfMib.dwIndex,
1108 &Adapter->NteContext,
1109 &Adapter->NteInstance);
1110 return;
1111 }
1112 }
1113 }
1114}
unsigned short int uint16_t
Definition: acefiex.h:54
Definition: bufpool.h:45
#define BufferSize
Definition: mmc.h:75
#define DbgPrint
Definition: hal.h:12
void __cdecl srand(_In_ unsigned int _Seed)
DWORD WINAPI AddIPAddress(IPAddr Address, IPMask Netmask, DWORD IfIndex, PULONG NteContext, PULONG NteInstance)
Definition: iphlpapi_main.c:67
DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
ULONG IPAddr
Definition: pfhook.h:35
ULONG NteInstance
Definition: rosdhcp.h:70
MIB_IFROW IfMib
Definition: rosdhcp.h:66
DWORD dwIndex
Definition: ifmib.h:38
int ret
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:254

Referenced by send_discover().

◆ state_reboot()

void state_reboot ( void ipp)

Definition at line 172 of file dhclient.c.

173{
174 struct interface_info *ip = ipp;
176
177 /* If we don't remember an active lease, go straight to INIT. */
178 if (!ip->client->active || ip->client->active->is_bootp) {
179 state_init(ip);
180 return;
181 }
182
183 /* We are in the rebooting state. */
184 ip->client->state = S_REBOOTING;
185
186 /* make_request doesn't initialize xid because it normally comes
187 from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER,
188 so pick an xid now. */
189 ip->client->xid = RtlRandom(&foo);
190
191 /* Make a DHCPREQUEST packet, and set appropriate per-interface
192 flags. */
193 make_request(ip, ip->client->active);
194 ip->client->destination = iaddr_broadcast;
195 time(&ip->client->first_sending);
196 ip->client->interval = ip->client->config->initial_interval;
197
198 /* Zap the medium list... */
199 ip->client->medium = NULL;
200
201 /* Send out the first DHCPREQUEST packet. */
203}

Referenced by DSAcquireParams(), DSLeaseIpAddress(), and DSRenewIpAddressLease().

◆ state_requesting()

void state_requesting ( void )

◆ state_selecting()

void state_selecting ( void ipp)

Definition at line 235 of file dhclient.c.

236{
237 struct interface_info *ip = ipp;
238 struct client_lease *lp, *next, *picked;
240
242
243 time(&cur_time);
244
245 /* Cancel state_selecting and send_discover timeouts, since either
246 one could have got us here. */
249
250 /* We have received one or more DHCPOFFER packets. Currently,
251 the only criterion by which we judge leases is whether or
252 not we get a response when we arp for them. */
253 picked = NULL;
254 for (lp = ip->client->offered_leases; lp; lp = next) {
255 next = lp->next;
256
257 /* Check to see if we got an ARPREPLY for the address
258 in this particular lease. */
259 if (!picked) {
260 if( !check_arp(ip,lp) ) goto freeit;
261 picked = lp;
262 picked->next = NULL;
263 } else {
264freeit:
266 }
267 }
268 ip->client->offered_leases = NULL;
269
270 /* If we just tossed all the leases we were offered, go back
271 to square one. */
272 if (!picked) {
273 ip->client->state = S_INIT;
274 state_init(ip);
275 return;
276 }
277
278 /* If it was a BOOTREPLY, we can just take the address right now. */
279 if (!picked->options[DHO_DHCP_MESSAGE_TYPE].len) {
280 ip->client->new = picked;
281
282 /* Make up some lease expiry times
283 XXX these should be configurable. */
284 ip->client->new->expiry = cur_time + 12000;
285 ip->client->new->renewal += cur_time + 8000;
286 ip->client->new->rebind += cur_time + 10000;
287
288 ip->client->state = S_REQUESTING;
289
290 /* Bind to the address we received. */
291 bind_lease(ip);
292 return;
293 }
294
295 /* Go to the REQUESTING state. */
296 ip->client->destination = iaddr_broadcast;
297 ip->client->state = S_REQUESTING;
298 ip->client->first_sending = cur_time;
299 ip->client->interval = ip->client->config->initial_interval;
300
301 /* Make a DHCPREQUEST packet from the lease we picked. */
302 make_request(ip, picked);
303 ip->client->xid = ip->client->packet.xid;
304
305 /* Toss the lease we picked - we'll get it back in a DHCPACK. */
306 free_client_lease(picked);
307
308 /* Add an immediate timeout to send the first DHCPREQUEST packet. */
310}

Referenced by dhcpoffer(), and state_selecting().

◆ subnet_number()

struct iaddr subnet_number ( struct iaddr  addr,
struct iaddr  mask 
)

Definition at line 172 of file util.c.

172 {
173 struct iaddr bcast = { 0 };
174 return bcast;
175}

Referenced by priv_script_write_params().

◆ warning()

void int warning ( char format,
  ... 
)

Definition at line 129 of file uimain.c.

786{
787 va_list ap;
788 char text[512];
789 char text1[512];
790
791 sprintf(text1, "WARNING: ");
794 va_end(ap);
795 strcat(text1, text);
796 mi_warning(text1);
797}
void mi_warning(char *msg)
Definition: win32.c:848

◆ write_client_lease()

void write_client_lease ( struct interface_info ip,
struct client_lease lease,
int  rewrite 
)

Definition at line 1559 of file dhclient.c.

1561{
1562 static int leases_written;
1563 struct tm *t;
1564 int i;
1565
1566 if (!rewrite) {
1567 if (leases_written++ > 20) {
1569 leases_written = 0;
1570 }
1571 }
1572
1573 /* If the lease came from the config file, we don't need to stash
1574 a copy in the lease database. */
1575 if (lease->is_static)
1576 return;
1577
1578 if (!leaseFile) { /* XXX */
1580 if (!leaseFile) {
1581 error("can't create %s", path_dhclient_db);
1582 return;
1583 }
1584 }
1585
1586 fprintf(leaseFile, "lease {\n");
1587 if (lease->is_bootp)
1588 fprintf(leaseFile, " bootp;\n");
1589 fprintf(leaseFile, " interface \"%s\";\n", ip->name);
1590 fprintf(leaseFile, " fixed-address %s;\n", piaddr(lease->address));
1591 if (lease->filename)
1592 fprintf(leaseFile, " filename \"%s\";\n", lease->filename);
1593 if (lease->server_name)
1594 fprintf(leaseFile, " server-name \"%s\";\n",
1595 lease->server_name);
1596 if (lease->medium)
1597 fprintf(leaseFile, " medium \"%s\";\n", lease->medium->string);
1598 for (i = 0; i < 256; i++)
1599 if (lease->options[i].len)
1600 fprintf(leaseFile, " option %s %s;\n",
1602 pretty_print_option(i, lease->options[i].data,
1603 lease->options[i].len, 1, 1));
1604
1605 t = gmtime(&lease->renewal);
1606 if (t)
1607 fprintf(leaseFile, " renew %d %d/%d/%d %02d:%02d:%02d;\n",
1608 t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
1609 t->tm_hour, t->tm_min, t->tm_sec);
1610 t = gmtime(&lease->rebind);
1611 if (t)
1612 fprintf(leaseFile, " rebind %d %d/%d/%d %02d:%02d:%02d;\n",
1613 t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
1614 t->tm_hour, t->tm_min, t->tm_sec);
1615 t = gmtime(&lease->expiry);
1616 if (t)
1617 fprintf(leaseFile, " expire %d %d/%d/%d %02d:%02d:%02d;\n",
1618 t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
1619 t->tm_hour, t->tm_min, t->tm_sec);
1620 fprintf(leaseFile, "}\n");
1622}
void rewrite_client_leases(struct interface_info *ifi)
Definition: dhclient.c:1537
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
_CRTIMP struct tm *__cdecl gmtime(const time_t *_Time)
Definition: time.h:415
unsigned int is_static
Definition: dhcpd.h:164
time_t renewal
Definition: dhcpd.h:155
time_t rebind
Definition: dhcpd.h:155
Definition: time.h:68

Referenced by rewrite_client_leases().

Variable Documentation

◆ bootp_packet_handler

Definition at line 59 of file dispatch.c.

Referenced by got_one(), and init_client().

◆ comment_index

int comment_index
extern

◆ comments

char comments[4096]
extern

◆ cur_time

◆ dhcp_option_default_priority_list

unsigned char dhcp_option_default_priority_list[]
extern

Definition at line 329 of file tables.c.

Referenced by cons_options().

◆ dhcp_options

◆ dhcp_universe

struct universe dhcp_universe
extern

Definition at line 67 of file tables.c.

Referenced by initialize_universes().

◆ eol_token

int eol_token
extern

◆ lexchar

void int int int int int lexchar

Definition at line 308 of file dhcpd.h.

◆ lexline

void int int int int int lexline
extern

◆ log_perror

int log_perror
extern

Definition at line 76 of file dhclient.c.

◆ log_priority

int log_priority
extern

Definition at line 92 of file dhclient.c.

◆ path_dhclient_conf

char* path_dhclient_conf
extern

Definition at line 73 of file dhclient.c.

◆ path_dhclient_db

char* path_dhclient_db
extern

Definition at line 74 of file dhclient.c.

Referenced by rewrite_client_leases(), and write_client_lease().

◆ sizeof_dhcp_option_default_priority_list

int sizeof_dhcp_option_default_priority_list
extern

Definition at line 408 of file tables.c.

Referenced by cons_options().

◆ tlname

char * tlname

Definition at line 309 of file dhcpd.h.

◆ token_line

char* token_line
extern

◆ top_level_config

struct client_config top_level_config
extern

◆ universe_hash

struct hash_table universe_hash
extern

Definition at line 672 of file tables.c.

Referenced by initialize_universes().

◆ warnings_occurred

int warnings_occurred
extern