blob: 6840f3c259a93fa8de318acf76b9a74bc554dbbc
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * DHCP server config and lease file manipulation |
4 | * |
5 | * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001 |
6 | * |
7 | * Licensed under GPLv2, see file LICENSE in this source tree. |
8 | */ |
9 | #include <netinet/ether.h> |
10 | |
11 | #include "common.h" |
12 | #include "dhcpd.h" |
13 | |
14 | /* on these functions, make sure your datatype matches */ |
15 | static int FAST_FUNC read_str(const char *line, void *arg) |
16 | { |
17 | char **dest = arg; |
18 | |
19 | free(*dest); |
20 | *dest = xstrdup(line); |
21 | return 1; |
22 | } |
23 | |
24 | static int FAST_FUNC read_u32(const char *line, void *arg) |
25 | { |
26 | *(uint32_t*)arg = bb_strtou32(line, NULL, 10); |
27 | return errno == 0; |
28 | } |
29 | |
30 | static int FAST_FUNC read_staticlease(const char *const_line, void *arg) |
31 | { |
32 | char *line; |
33 | char *mac_string; |
34 | char *ip_string; |
35 | struct ether_addr mac_bytes; /* it's "struct { uint8_t mac[6]; }" */ |
36 | uint32_t nip; |
37 | |
38 | /* Read mac */ |
39 | line = (char *) const_line; |
40 | mac_string = strtok_r(line, " \t", &line); |
41 | if (!mac_string || !ether_aton_r(mac_string, &mac_bytes)) |
42 | return 0; |
43 | |
44 | /* Read ip */ |
45 | ip_string = strtok_r(NULL, " \t", &line); |
46 | if (!ip_string || !udhcp_str2nip(ip_string, &nip)) |
47 | return 0; |
48 | |
49 | add_static_lease(arg, (uint8_t*) &mac_bytes, nip); |
50 | |
51 | log_static_leases(arg); |
52 | |
53 | return 1; |
54 | } |
55 | |
56 | |
57 | struct config_keyword { |
58 | const char *keyword; |
59 | int (*handler)(const char *line, void *var) FAST_FUNC; |
60 | void *var; |
61 | const char *def; |
62 | }; |
63 | |
64 | static const struct config_keyword keywords[] = { |
65 | /* keyword handler variable address default */ |
66 | {"start" , udhcp_str2nip , &server_config.start_ip , "192.168.0.20"}, |
67 | {"end" , udhcp_str2nip , &server_config.end_ip , "192.168.0.254"}, |
68 | {"interface" , read_str , &server_config.interface , "eth0"}, |
69 | /* Avoid "max_leases value not sane" warning by setting default |
70 | * to default_end_ip - default_start_ip + 1: */ |
71 | {"max_leases" , read_u32 , &server_config.max_leases , "235"}, |
72 | {"auto_time" , read_u32 , &server_config.auto_time , "7200"}, |
73 | {"decline_time" , read_u32 , &server_config.decline_time , "3600"}, |
74 | {"conflict_time", read_u32 , &server_config.conflict_time, "3600"}, |
75 | {"offer_time" , read_u32 , &server_config.offer_time , "60"}, |
76 | {"min_lease" , read_u32 , &server_config.min_lease_sec, "60"}, |
77 | {"lease_file" , read_str , &server_config.lease_file , LEASES_FILE}, |
78 | {"pidfile" , read_str , &server_config.pidfile , "/var/run/udhcpd.pid"}, |
79 | {"siaddr" , udhcp_str2nip , &server_config.siaddr_nip , "0.0.0.0"}, |
80 | /* keywords with no defaults must be last! */ |
81 | {"option" , udhcp_str2optset, &server_config.options , ""}, |
82 | {"opt" , udhcp_str2optset, &server_config.options , ""}, |
83 | {"notify_file" , read_str , &server_config.notify_file , NULL}, |
84 | {"sname" , read_str , &server_config.sname , NULL}, |
85 | {"boot_file" , read_str , &server_config.boot_file , NULL}, |
86 | {"static_lease" , read_staticlease, &server_config.static_leases, ""}, |
87 | }; |
88 | enum { KWS_WITH_DEFAULTS = ARRAY_SIZE(keywords) - 6 }; |
89 | |
90 | void FAST_FUNC read_config(const char *file) |
91 | { |
92 | parser_t *parser; |
93 | const struct config_keyword *k; |
94 | unsigned i; |
95 | char *token[2]; |
96 | |
97 | for (i = 0; i < KWS_WITH_DEFAULTS; i++) |
98 | keywords[i].handler(keywords[i].def, keywords[i].var); |
99 | |
100 | parser = config_open(file); |
101 | while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL)) { |
102 | for (k = keywords, i = 0; i < ARRAY_SIZE(keywords); k++, i++) { |
103 | if (strcasecmp(token[0], k->keyword) == 0) { |
104 | if (!k->handler(token[1], k->var)) { |
105 | bb_error_msg("can't parse line %u in %s", |
106 | parser->lineno, file); |
107 | /* reset back to the default value */ |
108 | k->handler(k->def, k->var); |
109 | } |
110 | break; |
111 | } |
112 | } |
113 | } |
114 | config_close(parser); |
115 | |
116 | server_config.start_ip = ntohl(server_config.start_ip); |
117 | server_config.end_ip = ntohl(server_config.end_ip); |
118 | } |
119 | |
120 | void FAST_FUNC write_leases(void) |
121 | { |
122 | int fd; |
123 | unsigned i; |
124 | leasetime_t curr; |
125 | int64_t written_at; |
126 | |
127 | fd = open_or_warn(server_config.lease_file, O_WRONLY|O_CREAT|O_TRUNC); |
128 | if (fd < 0) |
129 | return; |
130 | |
131 | curr = written_at = time(NULL); |
132 | |
133 | written_at = SWAP_BE64(written_at); |
134 | full_write(fd, &written_at, sizeof(written_at)); |
135 | |
136 | for (i = 0; i < server_config.max_leases; i++) { |
137 | leasetime_t tmp_time; |
138 | |
139 | if (g_leases[i].lease_nip == 0) |
140 | continue; |
141 | |
142 | /* Screw with the time in the struct, for easier writing */ |
143 | tmp_time = g_leases[i].expires; |
144 | |
145 | g_leases[i].expires -= curr; |
146 | if ((signed_leasetime_t) g_leases[i].expires < 0) |
147 | g_leases[i].expires = 0; |
148 | g_leases[i].expires = htonl(g_leases[i].expires); |
149 | |
150 | /* No error check. If the file gets truncated, |
151 | * we lose some leases on restart. Oh well. */ |
152 | full_write(fd, &g_leases[i], sizeof(g_leases[i])); |
153 | |
154 | /* Then restore it when done */ |
155 | g_leases[i].expires = tmp_time; |
156 | } |
157 | close(fd); |
158 | |
159 | if (server_config.notify_file) { |
160 | char *argv[3]; |
161 | argv[0] = server_config.notify_file; |
162 | argv[1] = server_config.lease_file; |
163 | argv[2] = NULL; |
164 | spawn_and_wait(argv); |
165 | } |
166 | } |
167 | |
168 | void FAST_FUNC read_leases(const char *file) |
169 | { |
170 | struct dyn_lease lease; |
171 | int64_t written_at, time_passed; |
172 | int fd; |
173 | #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1 |
174 | unsigned i = 0; |
175 | #endif |
176 | |
177 | fd = open_or_warn(file, O_RDONLY); |
178 | if (fd < 0) |
179 | return; |
180 | |
181 | if (full_read(fd, &written_at, sizeof(written_at)) != sizeof(written_at)) |
182 | goto ret; |
183 | written_at = SWAP_BE64(written_at); |
184 | |
185 | time_passed = time(NULL) - written_at; |
186 | /* Strange written_at, or lease file from old version of udhcpd |
187 | * which had no "written_at" field? */ |
188 | if ((uint64_t)time_passed > 12 * 60 * 60) |
189 | goto ret; |
190 | |
191 | while (full_read(fd, &lease, sizeof(lease)) == sizeof(lease)) { |
192 | //FIXME: what if it matches some static lease? |
193 | uint32_t y = ntohl(lease.lease_nip); |
194 | if (y >= server_config.start_ip && y <= server_config.end_ip) { |
195 | signed_leasetime_t expires = ntohl(lease.expires) - (signed_leasetime_t)time_passed; |
196 | if (expires <= 0) |
197 | continue; |
198 | /* NB: add_lease takes "relative time", IOW, |
199 | * lease duration, not lease deadline. */ |
200 | if (add_lease(lease.lease_mac, lease.lease_nip, |
201 | expires, |
202 | lease.hostname, sizeof(lease.hostname) |
203 | ) == 0 |
204 | ) { |
205 | bb_error_msg("too many leases while loading %s", file); |
206 | break; |
207 | } |
208 | #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1 |
209 | i++; |
210 | #endif |
211 | } |
212 | } |
213 | log1("Read %d leases", i); |
214 | ret: |
215 | close(fd); |
216 | } |
217 |