Print this page
7388 Support DHCP Client FQDN. Allow IAID/DUID for all v4.
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/cmd-inet/usr.sbin/nwamcfg/nwamcfg_lex.l
+++ new/usr/src/cmd/cmd-inet/usr.sbin/nwamcfg/nwamcfg_lex.l
1 1 %{
2 2 /*
3 3 * CDDL HEADER START
4 4 *
5 5 * The contents of this file are subject to the terms of the
6 6 * Common Development and Distribution License (the "License").
7 7 * You may not use this file except in compliance with the License.
8 8 *
9 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 10 * or http://www.opensolaris.org/os/licensing.
11 11 * See the License for the specific language governing permissions
12 12 * and limitations under the License.
13 13 *
14 14 * When distributing Covered Code, include this CDDL HEADER in each
15 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
16 16 * If applicable, add the following below this CDDL HEADER, with the
17 17 * fields enclosed by brackets "[]" replaced with your own identifying
18 18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 19 *
20 20 * CDDL HEADER END
21 21 */
22 22
23 23 /*
24 24 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
25 25 * Use is subject to license terms.
26 + * Copyright (c) 2016, Chris Fraire <cfraire@me.com>.
26 27 */
27 28
28 29 #include <string.h>
29 30 #include <libintl.h>
30 31 #include <sys/types.h>
31 32 #include "nwamcfg.h"
32 33 #include "nwamcfg_grammar.tab.h"
33 34
34 35 int lex_lineno = 1; /* line number for error reporting */
35 36 static int state = INITIAL;
36 37 extern boolean_t cmd_file_mode;
37 38
38 39 extern void yyerror(char *s);
39 40 char *safe_strdup(char *s);
40 41 %}
41 42
42 43 %a 7000
43 44 %p 5000
44 45 %e 2000
45 46 %n 800
46 47 %o 12000
47 48
48 49 %{
49 50 /*
50 51 * The state below are for tokens.
51 52 */
52 53 %}
53 54 %s TSTATE
54 55 %%
55 56
56 57 <INITIAL>"#"[^\n]* { }
57 58
58 59 <INITIAL>cancel {
59 60 BEGIN TSTATE;
60 61 state = TSTATE;
61 62 return CANCEL;
62 63 }
63 64
64 65 <INITIAL>clear {
65 66 BEGIN TSTATE;
66 67 state = TSTATE;
67 68 return CLEAR;
68 69 }
69 70
70 71 <INITIAL>commit {
71 72 BEGIN TSTATE;
72 73 state = TSTATE;
73 74 return COMMIT;
74 75 }
75 76
76 77 <INITIAL>create {
77 78 BEGIN TSTATE;
78 79 state = TSTATE;
79 80 return CREATE;
80 81 }
81 82
82 83
83 84 <INITIAL>destroy {
84 85 BEGIN TSTATE;
85 86 state = TSTATE;
86 87 return DESTROY;
87 88 }
88 89
89 90 <INITIAL>end {
90 91 BEGIN TSTATE;
91 92 state = TSTATE;
92 93 return END;
93 94 }
94 95
95 96 <INITIAL>exit|quit {
96 97 BEGIN TSTATE;
97 98 state = TSTATE;
98 99 return EXIT;
99 100 }
100 101
101 102 <INITIAL>export {
102 103 BEGIN TSTATE;
103 104 state = TSTATE;
104 105 return EXPORT;
105 106 }
106 107
107 108 <INITIAL>get {
108 109 BEGIN TSTATE;
109 110 state = TSTATE;
110 111 return GET;
111 112 }
112 113
113 114 <INITIAL>"?"|help {
114 115 BEGIN TSTATE;
115 116 state = TSTATE;
116 117 return HELP;
117 118 }
118 119
119 120 <INITIAL>list {
120 121 BEGIN TSTATE;
121 122 state = TSTATE;
122 123 return LIST;
123 124 }
124 125
125 126 <INITIAL>revert {
126 127 BEGIN TSTATE;
127 128 state = TSTATE;
128 129 return REVERT;
129 130 }
130 131
131 132 <INITIAL>select {
132 133 BEGIN TSTATE;
133 134 state = TSTATE;
134 135 return SELECT;
135 136 }
136 137
137 138 <INITIAL>set {
138 139 BEGIN TSTATE;
139 140 state = TSTATE;
140 141 return SET;
141 142 }
142 143
143 144 <INITIAL>verify {
144 145 BEGIN TSTATE;
145 146 state = TSTATE;
146 147 return VERIFY;
147 148 }
148 149
149 150 <INITIAL>walkprop {
150 151 BEGIN TSTATE;
151 152 state = TSTATE;
152 153 return WALKPROP;
153 154 }
154 155
155 156 <TSTATE>[Ll][Oo][Cc] { return LOC; }
156 157 <TSTATE>[Nn][Cc][Pp] { return NCP; }
157 158 <TSTATE>[Ee][Nn][Mm] { return ENM; }
158 159 <TSTATE>[Ww][Ll][Aa][Nn] { return WLAN; }
159 160
160 161 <TSTATE>[Nn][Cc][Uu] { return NCU; }
161 162
162 163 <TSTATE>[Pp][Hh][Yy][Ss] { return PHYS; }
163 164 <TSTATE>[Ii][Pp] { return IP; }
164 165
165 166 <TSTATE>unknown { return UNKNOWN; }
166 167 <TSTATE>activation-mode { return ACTIVATION_MODE; }
167 168 <TSTATE>conditions { return CONDITIONS; }
168 169 <TSTATE>enabled { return ENABLED; }
169 170
170 171 <TSTATE>type { return TYPE; }
171 172 <TSTATE>class { return CLASS; }
172 173 <TSTATE>parent { return PARENT; }
173 174 <TSTATE>priority-group { return PRIORITY_GROUP; }
174 175 <TSTATE>priority-mode { return PRIORITY_MODE; }
|
↓ open down ↓ |
139 lines elided |
↑ open up ↑ |
175 176 <TSTATE>link-mac-addr { return LINK_MACADDR; }
176 177 <TSTATE>link-autopush { return LINK_AUTOPUSH; }
177 178 <TSTATE>link-mtu { return LINK_MTU; }
178 179 <TSTATE>ip-version { return IP_VERSION; }
179 180 <TSTATE>ipv4-addrsrc { return IPV4_ADDRSRC; }
180 181 <TSTATE>ipv4-addr { return IPV4_ADDR; }
181 182 <TSTATE>ipv4-default-route { return IPV4_DEFAULT_ROUTE; }
182 183 <TSTATE>ipv6-addrsrc { return IPV6_ADDRSRC; }
183 184 <TSTATE>ipv6-addr { return IPV6_ADDR; }
184 185 <TSTATE>ipv6-default-route { return IPV6_DEFAULT_ROUTE; }
186 +<TSTATE>ip-primary { return IP_PRIMARY; }
187 +<TSTATE>ip-reqhost { return IP_REQHOST; }
185 188
186 189 <TSTATE>state { return ENM_STATE; }
187 190 <TSTATE>fmri { return ENM_FMRI; }
188 191 <TSTATE>start { return ENM_START; }
189 192 <TSTATE>stop { return ENM_STOP; }
190 193
191 194 <TSTATE>nameservices { return LOC_NAMESERVICES; }
192 195 <TSTATE>nameservices-config-file { return LOC_NAMESERVICES_CONFIG; }
193 196 <TSTATE>dns-nameservice-configsrc { return LOC_DNS_CONFIGSRC; }
194 197 <TSTATE>dns-nameservice-domain { return LOC_DNS_DOMAIN; }
195 198 <TSTATE>dns-nameservice-servers { return LOC_DNS_SERVERS; }
196 199 <TSTATE>dns-nameservice-search { return LOC_DNS_SEARCH; }
197 200 <TSTATE>nis-nameservice-configsrc { return LOC_NIS_CONFIGSRC; }
198 201 <TSTATE>nis-nameservice-servers { return LOC_NIS_SERVERS; }
199 202 <TSTATE>ldap-nameservice-configsrc { return LOC_LDAP_CONFIGSRC; }
200 203 <TSTATE>ldap-nameservice-servers { return LOC_LDAP_SERVERS; }
201 204 <TSTATE>default-domain { return LOC_DEFAULT_DOMAIN; }
202 205 <TSTATE>nfsv4-domain { return LOC_NFSV4_DOMAIN; }
203 206 <TSTATE>ipfilter-config-file { return LOC_IPF_CONFIG; }
204 207 <TSTATE>ipfilter-v6-config-file { return LOC_IPF_V6_CONFIG; }
205 208 <TSTATE>ipnat-config-file { return LOC_IPNAT_CONFIG; }
206 209 <TSTATE>ippool-config-file { return LOC_IPPOOL_CONFIG; }
207 210 <TSTATE>ike-config-file { return LOC_IKE_CONFIG; }
208 211 <TSTATE>ipsecpolicy-config-file { return LOC_IPSECPOL_CONFIG; }
209 212
210 213 <TSTATE>bssids { return WLAN_BSSIDS; }
211 214 <TSTATE>priority { return WLAN_PRIORITY; }
212 215 <TSTATE>keyname { return WLAN_KEYNAME; }
213 216 <TSTATE>keyslot { return WLAN_KEYSLOT; }
214 217 <TSTATE>security-mode { return WLAN_SECURITY_MODE; }
215 218
216 219 <TSTATE>= { return EQUAL; }
217 220
218 221 <TSTATE>\-[adftV] { /* matches options */
219 222 yylval.strval = safe_strdup(yytext);
220 223 return OPTION;
221 224 }
222 225
223 226 <TSTATE>[^ \t\n\";=\[\]\(\)]+ { /* matches non-quoted values */
224 227 yylval.strval = safe_strdup(yytext);
225 228 return TOKEN;
226 229 }
227 230
228 231 <TSTATE>\"[^\"\n]*[\"\n] { /* matches string with quotes */
229 232 yylval.strval = safe_strdup(yytext);
230 233 return TOKEN;
231 234 }
232 235
233 236 <TSTATE>\".*\"\,\".*\" { /* matches string list of the form "a","b",.. */
234 237 yylval.strval = safe_strdup(yytext);
235 238 return TOKEN;
236 239 }
237 240
238 241 ";" {
239 242 BEGIN INITIAL;
240 243 return (yytext[0]);
241 244 }
242 245
243 246 \n {
244 247 lex_lineno++;
245 248 BEGIN INITIAL;
246 249 return (yytext[0]);
247 250 }
248 251
249 252 [ \t] ; /* ignore white space */
250 253
251 254 . { /* matches all single otherwise unmatched characters */
252 255 return (yytext[0]);
253 256 }
254 257
255 258 %%
256 259
257 260 char *
258 261 safe_strdup(char *s)
259 262 {
260 263 char *result;
261 264
262 265 if ((result = strdup(s)) == NULL) {
263 266 yyerror("Out of memory");
264 267 exit(1);
265 268 }
266 269 return (result);
267 270 }
268 271
269 272 void
270 273 yyerror(char *s)
271 274 {
272 275 /* feof(yyin) is not an error; anything else is, so we set saw_error */
273 276 if (yytext[0] == '\0') {
274 277 if (!feof(yyin)) {
275 278 saw_error = B_TRUE;
276 279 (void) fprintf(stderr, gettext("%s, token expected\n"),
277 280 s);
278 281 }
279 282 return;
280 283 }
281 284
282 285 saw_error = B_TRUE;
283 286 if (cmd_file_mode) {
284 287 (void) fprintf(stderr, gettext("%s on line %d at '%s'\n"), s,
285 288 lex_lineno, (yytext[0] == '\n') ? "\\n" : yytext);
286 289 } else {
287 290 (void) fprintf(stderr, gettext("%s at '%s'\n\n"), s,
288 291 (yytext[0] == '\n') ? "\\n" : yytext);
289 292 }
290 293 help_wrap();
291 294 }
|
↓ open down ↓ |
97 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX