Index: head/usr.bin/iscsictl/parse.y =================================================================== --- head/usr.bin/iscsictl/parse.y (revision 367247) +++ head/usr.bin/iscsictl/parse.y (revision 367248) @@ -1,433 +1,432 @@ %{ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2012 The FreeBSD Foundation * * This software was developed by Edward Tomasz Napierala under sponsorship * from the FreeBSD Foundation. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include "iscsictl.h" #include #include extern FILE *yyin; extern char *yytext; extern int lineno; static struct conf *conf; static struct target *target; extern void yyerror(const char *); -extern int yylex(void); extern void yyrestart(FILE *); %} %token AUTH_METHOD ENABLE HEADER_DIGEST DATA_DIGEST TARGET_NAME TARGET_ADDRESS %token INITIATOR_NAME INITIATOR_ADDRESS INITIATOR_ALIAS USER SECRET %token MUTUAL_USER MUTUAL_SECRET SEMICOLON SESSION_TYPE PROTOCOL OFFLOAD %token IGNORED EQUALS OPENING_BRACKET CLOSING_BRACKET DSCP %token AF11 AF12 AF13 AF21 AF22 AF23 AF31 AF32 AF33 AF41 AF42 AF43 %token BE EF CS0 CS1 CS2 CS3 CS4 CS5 CS6 CS7 %union { char *str; } %token STR %% targets: | targets target ; target: STR OPENING_BRACKET target_entries CLOSING_BRACKET { if (target_find(conf, $1) != NULL) xo_errx(1, "duplicated target %s", $1); target->t_nickname = $1; target = target_new(conf); } ; target_entries: | target_entries target_entry | target_entries target_entry SEMICOLON ; target_entry: target_name | target_address | initiator_name | initiator_address | initiator_alias | user | secret | mutual_user | mutual_secret | auth_method | header_digest | data_digest | session_type | enable | offload | protocol | ignored | dscp | pcp ; target_name: TARGET_NAME EQUALS STR { if (target->t_name != NULL) xo_errx(1, "duplicated TargetName at line %d", lineno); target->t_name = $3; } ; target_address: TARGET_ADDRESS EQUALS STR { if (target->t_address != NULL) xo_errx(1, "duplicated TargetAddress at line %d", lineno); target->t_address = $3; } ; initiator_name: INITIATOR_NAME EQUALS STR { if (target->t_initiator_name != NULL) xo_errx(1, "duplicated InitiatorName at line %d", lineno); target->t_initiator_name = $3; } ; initiator_address: INITIATOR_ADDRESS EQUALS STR { if (target->t_initiator_address != NULL) xo_errx(1, "duplicated InitiatorAddress at line %d", lineno); target->t_initiator_address = $3; } ; initiator_alias: INITIATOR_ALIAS EQUALS STR { if (target->t_initiator_alias != NULL) xo_errx(1, "duplicated InitiatorAlias at line %d", lineno); target->t_initiator_alias = $3; } ; user: USER EQUALS STR { if (target->t_user != NULL) xo_errx(1, "duplicated chapIName at line %d", lineno); target->t_user = $3; } ; secret: SECRET EQUALS STR { if (target->t_secret != NULL) xo_errx(1, "duplicated chapSecret at line %d", lineno); target->t_secret = $3; } ; mutual_user: MUTUAL_USER EQUALS STR { if (target->t_mutual_user != NULL) xo_errx(1, "duplicated tgtChapName at line %d", lineno); target->t_mutual_user = $3; } ; mutual_secret: MUTUAL_SECRET EQUALS STR { if (target->t_mutual_secret != NULL) xo_errx(1, "duplicated tgtChapSecret at line %d", lineno); target->t_mutual_secret = $3; } ; auth_method: AUTH_METHOD EQUALS STR { if (target->t_auth_method != AUTH_METHOD_UNSPECIFIED) xo_errx(1, "duplicated AuthMethod at line %d", lineno); if (strcasecmp($3, "none") == 0) target->t_auth_method = AUTH_METHOD_NONE; else if (strcasecmp($3, "chap") == 0) target->t_auth_method = AUTH_METHOD_CHAP; else xo_errx(1, "invalid AuthMethod at line %d; " "must be either \"none\" or \"CHAP\"", lineno); } ; header_digest: HEADER_DIGEST EQUALS STR { if (target->t_header_digest != DIGEST_UNSPECIFIED) xo_errx(1, "duplicated HeaderDigest at line %d", lineno); if (strcasecmp($3, "none") == 0) target->t_header_digest = DIGEST_NONE; else if (strcasecmp($3, "CRC32C") == 0) target->t_header_digest = DIGEST_CRC32C; else xo_errx(1, "invalid HeaderDigest at line %d; " "must be either \"none\" or \"CRC32C\"", lineno); } ; data_digest: DATA_DIGEST EQUALS STR { if (target->t_data_digest != DIGEST_UNSPECIFIED) xo_errx(1, "duplicated DataDigest at line %d", lineno); if (strcasecmp($3, "none") == 0) target->t_data_digest = DIGEST_NONE; else if (strcasecmp($3, "CRC32C") == 0) target->t_data_digest = DIGEST_CRC32C; else xo_errx(1, "invalid DataDigest at line %d; " "must be either \"none\" or \"CRC32C\"", lineno); } ; session_type: SESSION_TYPE EQUALS STR { if (target->t_session_type != SESSION_TYPE_UNSPECIFIED) xo_errx(1, "duplicated SessionType at line %d", lineno); if (strcasecmp($3, "normal") == 0) target->t_session_type = SESSION_TYPE_NORMAL; else if (strcasecmp($3, "discovery") == 0) target->t_session_type = SESSION_TYPE_DISCOVERY; else xo_errx(1, "invalid SessionType at line %d; " "must be either \"normal\" or \"discovery\"", lineno); } ; enable: ENABLE EQUALS STR { if (target->t_enable != ENABLE_UNSPECIFIED) xo_errx(1, "duplicated enable at line %d", lineno); target->t_enable = parse_enable($3); if (target->t_enable == ENABLE_UNSPECIFIED) xo_errx(1, "invalid enable at line %d; " "must be either \"on\" or \"off\"", lineno); } ; offload: OFFLOAD EQUALS STR { if (target->t_offload != NULL) xo_errx(1, "duplicated offload at line %d", lineno); target->t_offload = $3; } ; protocol: PROTOCOL EQUALS STR { if (target->t_protocol != PROTOCOL_UNSPECIFIED) xo_errx(1, "duplicated protocol at line %d", lineno); if (strcasecmp($3, "iscsi") == 0) target->t_protocol = PROTOCOL_ISCSI; else if (strcasecmp($3, "iser") == 0) target->t_protocol = PROTOCOL_ISER; else xo_errx(1, "invalid protocol at line %d; " "must be either \"iscsi\" or \"iser\"", lineno); } ; ignored: IGNORED EQUALS STR { xo_warnx("obsolete statement ignored at line %d", lineno); } ; dscp: DSCP EQUALS STR { uint64_t tmp; if (target->t_dscp != -1) xo_errx(1, "duplicated dscp at line %d", lineno); if (strcmp($3, "0x") == 0) { tmp = strtol($3 + 2, NULL, 16); } else if (expand_number($3, &tmp) != 0) { yyerror("invalid numeric value"); free($3); return(1); } if (tmp >= 0x40) { yyerror("invalid dscp value"); return(1); } target->t_dscp = tmp; } | DSCP EQUALS BE { target->t_dscp = IPTOS_DSCP_CS0 >> 2 ; } | DSCP EQUALS EF { target->t_dscp = IPTOS_DSCP_EF >> 2 ; } | DSCP EQUALS CS0 { target->t_dscp = IPTOS_DSCP_CS0 >> 2 ; } | DSCP EQUALS CS1 { target->t_dscp = IPTOS_DSCP_CS1 >> 2 ; } | DSCP EQUALS CS2 { target->t_dscp = IPTOS_DSCP_CS2 >> 2 ; } | DSCP EQUALS CS3 { target->t_dscp = IPTOS_DSCP_CS3 >> 2 ; } | DSCP EQUALS CS4 { target->t_dscp = IPTOS_DSCP_CS4 >> 2 ; } | DSCP EQUALS CS5 { target->t_dscp = IPTOS_DSCP_CS5 >> 2 ; } | DSCP EQUALS CS6 { target->t_dscp = IPTOS_DSCP_CS6 >> 2 ; } | DSCP EQUALS CS7 { target->t_dscp = IPTOS_DSCP_CS7 >> 2 ; } | DSCP EQUALS AF11 { target->t_dscp = IPTOS_DSCP_AF11 >> 2 ; } | DSCP EQUALS AF12 { target->t_dscp = IPTOS_DSCP_AF12 >> 2 ; } | DSCP EQUALS AF13 { target->t_dscp = IPTOS_DSCP_AF13 >> 2 ; } | DSCP EQUALS AF21 { target->t_dscp = IPTOS_DSCP_AF21 >> 2 ; } | DSCP EQUALS AF22 { target->t_dscp = IPTOS_DSCP_AF22 >> 2 ; } | DSCP EQUALS AF23 { target->t_dscp = IPTOS_DSCP_AF23 >> 2 ; } | DSCP EQUALS AF31 { target->t_dscp = IPTOS_DSCP_AF31 >> 2 ; } | DSCP EQUALS AF32 { target->t_dscp = IPTOS_DSCP_AF32 >> 2 ; } | DSCP EQUALS AF33 { target->t_dscp = IPTOS_DSCP_AF33 >> 2 ; } | DSCP EQUALS AF41 { target->t_dscp = IPTOS_DSCP_AF41 >> 2 ; } | DSCP EQUALS AF42 { target->t_dscp = IPTOS_DSCP_AF42 >> 2 ; } | DSCP EQUALS AF43 { target->t_dscp = IPTOS_DSCP_AF43 >> 2 ; } ; pcp: PCP EQUALS STR { uint64_t tmp; if (target->t_pcp != -1) xo_errx(1, "duplicated pcp at line %d", lineno); if (expand_number($3, &tmp) != 0) { yyerror("invalid numeric value"); free($3); return(1); } - if (!((tmp >=0) && (tmp <= 7))) { + if (tmp > 7) { yyerror("invalid pcp value"); return(1); } target->t_pcp = tmp; } ; %% void yyerror(const char *str) { xo_errx(1, "error in configuration file at line %d near '%s': %s", lineno, yytext, str); } static void check_perms(const char *path) { struct stat sb; int error; error = stat(path, &sb); if (error != 0) { xo_warn("stat"); return; } if (sb.st_mode & S_IWOTH) { xo_warnx("%s is world-writable", path); } else if (sb.st_mode & S_IROTH) { xo_warnx("%s is world-readable", path); } else if (sb.st_mode & S_IXOTH) { /* * Ok, this one doesn't matter, but still do it, * just for consistency. */ xo_warnx("%s is world-executable", path); } /* * XXX: Should we also check for owner != 0? */ } struct conf * conf_new_from_file(const char *path) { int error; conf = conf_new(); target = target_new(conf); yyin = fopen(path, "r"); if (yyin == NULL) xo_err(1, "unable to open configuration file %s", path); check_perms(path); lineno = 1; yyrestart(yyin); error = yyparse(); assert(error == 0); fclose(yyin); assert(target->t_nickname == NULL); target_delete(target); conf_verify(conf); return (conf); }