Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 1 | /* Copyright (c) 2014, Google Inc. |
| 2 | * |
| 3 | * Permission to use, copy, modify, and/or distribute this software for any |
| 4 | * purpose with or without fee is hereby granted, provided that the above |
| 5 | * copyright notice and this permission notice appear in all copies. |
| 6 | * |
| 7 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| 8 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| 9 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
| 10 | * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 11 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| 12 | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 13 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ |
| 14 | |
| 15 | #include "test_config.h" |
| 16 | |
| 17 | #include <stdio.h> |
| 18 | #include <stdlib.h> |
| 19 | #include <string.h> |
| 20 | |
| 21 | #include <memory> |
| 22 | |
| 23 | #include <openssl/base64.h> |
| 24 | |
| 25 | namespace { |
| 26 | |
| 27 | template <typename T> |
| 28 | struct Flag { |
| 29 | const char *flag; |
| 30 | T TestConfig::*member; |
| 31 | }; |
| 32 | |
| 33 | // FindField looks for the flag in |flags| that matches |flag|. If one is found, |
| 34 | // it returns a pointer to the corresponding field in |config|. Otherwise, it |
| 35 | // returns NULL. |
| 36 | template<typename T, size_t N> |
| 37 | T *FindField(TestConfig *config, const Flag<T> (&flags)[N], const char *flag) { |
| 38 | for (size_t i = 0; i < N; i++) { |
| 39 | if (strcmp(flag, flags[i].flag) == 0) { |
| 40 | return &(config->*(flags[i].member)); |
| 41 | } |
| 42 | } |
| 43 | return NULL; |
| 44 | } |
| 45 | |
| 46 | const Flag<bool> kBoolFlags[] = { |
| 47 | { "-server", &TestConfig::is_server }, |
| 48 | { "-dtls", &TestConfig::is_dtls }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 49 | { "-fallback-scsv", &TestConfig::fallback_scsv }, |
| 50 | { "-require-any-client-certificate", |
| 51 | &TestConfig::require_any_client_certificate }, |
| 52 | { "-false-start", &TestConfig::false_start }, |
| 53 | { "-async", &TestConfig::async }, |
| 54 | { "-write-different-record-sizes", |
| 55 | &TestConfig::write_different_record_sizes }, |
| 56 | { "-cbc-record-splitting", &TestConfig::cbc_record_splitting }, |
| 57 | { "-partial-write", &TestConfig::partial_write }, |
David Benjamin | d316cba | 2016-06-02 16:17:39 -0400 | [diff] [blame] | 58 | { "-no-tls13", &TestConfig::no_tls13 }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 59 | { "-no-tls12", &TestConfig::no_tls12 }, |
| 60 | { "-no-tls11", &TestConfig::no_tls11 }, |
| 61 | { "-no-tls1", &TestConfig::no_tls1 }, |
| 62 | { "-no-ssl3", &TestConfig::no_ssl3 }, |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 63 | { "-enable-channel-id", &TestConfig::enable_channel_id }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 64 | { "-shim-writes-first", &TestConfig::shim_writes_first }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 65 | { "-expect-session-miss", &TestConfig::expect_session_miss }, |
David Benjamin | 4969cc9 | 2016-04-22 15:02:23 -0400 | [diff] [blame] | 66 | { "-decline-alpn", &TestConfig::decline_alpn }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 67 | { "-expect-extended-master-secret", |
| 68 | &TestConfig::expect_extended_master_secret }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 69 | { "-enable-ocsp-stapling", &TestConfig::enable_ocsp_stapling }, |
| 70 | { "-enable-signed-cert-timestamps", |
| 71 | &TestConfig::enable_signed_cert_timestamps }, |
Adam Langley | e9ada86 | 2015-05-11 17:20:37 -0700 | [diff] [blame] | 72 | { "-implicit-handshake", &TestConfig::implicit_handshake }, |
| 73 | { "-use-early-callback", &TestConfig::use_early_callback }, |
| 74 | { "-fail-early-callback", &TestConfig::fail_early_callback }, |
| 75 | { "-install-ddos-callback", &TestConfig::install_ddos_callback }, |
| 76 | { "-fail-ddos-callback", &TestConfig::fail_ddos_callback }, |
| 77 | { "-fail-second-ddos-callback", &TestConfig::fail_second_ddos_callback }, |
Steven Valdez | 909b19f | 2016-11-21 15:35:44 -0500 | [diff] [blame] | 78 | { "-fail-cert-callback", &TestConfig::fail_cert_callback }, |
Adam Langley | e9ada86 | 2015-05-11 17:20:37 -0700 | [diff] [blame] | 79 | { "-handshake-never-done", &TestConfig::handshake_never_done }, |
| 80 | { "-use-export-context", &TestConfig::use_export_context }, |
Adam Langley | f4e4272 | 2015-06-04 17:45:09 -0700 | [diff] [blame] | 81 | { "-tls-unique", &TestConfig::tls_unique }, |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 82 | { "-expect-ticket-renewal", &TestConfig::expect_ticket_renewal }, |
| 83 | { "-expect-no-session", &TestConfig::expect_no_session }, |
Robert Sloan | 69939df | 2017-01-09 10:53:07 -0800 | [diff] [blame] | 84 | { "-expect-early-data-info", &TestConfig::expect_early_data_info }, |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 85 | { "-use-ticket-callback", &TestConfig::use_ticket_callback }, |
| 86 | { "-renew-ticket", &TestConfig::renew_ticket }, |
Robert Sloan | 69939df | 2017-01-09 10:53:07 -0800 | [diff] [blame] | 87 | { "-enable-early-data", &TestConfig::enable_early_data }, |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 88 | { "-enable-client-custom-extension", |
| 89 | &TestConfig::enable_client_custom_extension }, |
| 90 | { "-enable-server-custom-extension", |
| 91 | &TestConfig::enable_server_custom_extension }, |
| 92 | { "-custom-extension-skip", &TestConfig::custom_extension_skip }, |
| 93 | { "-custom-extension-fail-add", &TestConfig::custom_extension_fail_add }, |
| 94 | { "-check-close-notify", &TestConfig::check_close_notify }, |
| 95 | { "-shim-shuts-down", &TestConfig::shim_shuts_down }, |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 96 | { "-verify-fail", &TestConfig::verify_fail }, |
| 97 | { "-verify-peer", &TestConfig::verify_peer }, |
Kenny Root | e99801b | 2015-11-06 15:31:15 -0800 | [diff] [blame] | 98 | { "-expect-verify-result", &TestConfig::expect_verify_result }, |
| 99 | { "-renegotiate-once", &TestConfig::renegotiate_once }, |
| 100 | { "-renegotiate-freely", &TestConfig::renegotiate_freely }, |
Adam Langley | fad6327 | 2015-11-12 12:15:39 -0800 | [diff] [blame] | 101 | { "-renegotiate-ignore", &TestConfig::renegotiate_ignore }, |
Adam Langley | 4139edb | 2016-01-13 15:00:54 -0800 | [diff] [blame] | 102 | { "-p384-only", &TestConfig::p384_only }, |
| 103 | { "-enable-all-curves", &TestConfig::enable_all_curves }, |
David Benjamin | 4969cc9 | 2016-04-22 15:02:23 -0400 | [diff] [blame] | 104 | { "-use-old-client-cert-callback", |
| 105 | &TestConfig::use_old_client_cert_callback }, |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 106 | { "-send-alert", &TestConfig::send_alert }, |
Steven Valdez | bb1ceac | 2016-10-07 10:34:51 -0400 | [diff] [blame] | 107 | { "-peek-then-read", &TestConfig::peek_then_read }, |
| 108 | { "-enable-grease", &TestConfig::enable_grease }, |
Steven Valdez | 909b19f | 2016-11-21 15:35:44 -0500 | [diff] [blame] | 109 | { "-use-exporter-between-reads", &TestConfig::use_exporter_between_reads }, |
| 110 | { "-retain-only-sha256-client-cert-initial", |
| 111 | &TestConfig::retain_only_sha256_client_cert_initial }, |
| 112 | { "-retain-only-sha256-client-cert-resume", |
| 113 | &TestConfig::retain_only_sha256_client_cert_resume }, |
| 114 | { "-expect-sha256-client-cert-initial", |
| 115 | &TestConfig::expect_sha256_client_cert_initial }, |
| 116 | { "-expect-sha256-client-cert-resume", |
| 117 | &TestConfig::expect_sha256_client_cert_resume }, |
Robert Sloan | 69939df | 2017-01-09 10:53:07 -0800 | [diff] [blame] | 118 | { "-read-with-unfinished-write", &TestConfig::read_with_unfinished_write }, |
Steven Valdez | b0b45c6 | 2017-01-17 16:23:54 -0500 | [diff] [blame] | 119 | { "-expect-secure-renegotiation", |
| 120 | &TestConfig::expect_secure_renegotiation }, |
| 121 | { "-expect-no-secure-renegotiation", |
| 122 | &TestConfig::expect_no_secure_renegotiation }, |
Robert Sloan | 4d1ac50 | 2017-02-06 08:36:14 -0800 | [diff] [blame] | 123 | { "-expect-session-id", &TestConfig::expect_session_id }, |
| 124 | { "-expect-no-session-id", &TestConfig::expect_no_session_id }, |
Robert Sloan | 6d0d00e | 2017-03-27 07:13:07 -0700 | [diff] [blame] | 125 | { "-expect-accept-early-data", &TestConfig::expect_accept_early_data }, |
| 126 | { "-expect-reject-early-data", &TestConfig::expect_reject_early_data }, |
Robert Sloan | 6f79a50 | 2017-04-03 09:16:40 -0700 | [diff] [blame] | 127 | { "-no-op-extra-handshake", &TestConfig::no_op_extra_handshake }, |
| 128 | { "-handshake-twice", &TestConfig::handshake_twice }, |
Robert Sloan | 572a4e2 | 2017-04-17 10:52:19 -0700 | [diff] [blame] | 129 | { "-allow-unknown-alpn-protos", &TestConfig::allow_unknown_alpn_protos }, |
| 130 | { "-enable-ed25519", &TestConfig::enable_ed25519 }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 131 | }; |
| 132 | |
| 133 | const Flag<std::string> kStringFlags[] = { |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 134 | { "-digest-prefs", &TestConfig::digest_prefs }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 135 | { "-key-file", &TestConfig::key_file }, |
| 136 | { "-cert-file", &TestConfig::cert_file }, |
| 137 | { "-expect-server-name", &TestConfig::expected_server_name }, |
| 138 | { "-advertise-npn", &TestConfig::advertise_npn }, |
| 139 | { "-expect-next-proto", &TestConfig::expected_next_proto }, |
| 140 | { "-select-next-proto", &TestConfig::select_next_proto }, |
| 141 | { "-send-channel-id", &TestConfig::send_channel_id }, |
| 142 | { "-host-name", &TestConfig::host_name }, |
| 143 | { "-advertise-alpn", &TestConfig::advertise_alpn }, |
| 144 | { "-expect-alpn", &TestConfig::expected_alpn }, |
| 145 | { "-expect-advertised-alpn", &TestConfig::expected_advertised_alpn }, |
| 146 | { "-select-alpn", &TestConfig::select_alpn }, |
| 147 | { "-psk", &TestConfig::psk }, |
| 148 | { "-psk-identity", &TestConfig::psk_identity }, |
| 149 | { "-srtp-profiles", &TestConfig::srtp_profiles }, |
Adam Langley | e9ada86 | 2015-05-11 17:20:37 -0700 | [diff] [blame] | 150 | { "-cipher", &TestConfig::cipher }, |
| 151 | { "-export-label", &TestConfig::export_label }, |
| 152 | { "-export-context", &TestConfig::export_context }, |
Steven Valdez | 909b19f | 2016-11-21 15:35:44 -0500 | [diff] [blame] | 153 | { "-expect-peer-cert-file", &TestConfig::expect_peer_cert_file }, |
Robert Sloan | 7d422bc | 2017-03-06 10:04:29 -0800 | [diff] [blame] | 154 | { "-use-client-ca-list", &TestConfig::use_client_ca_list }, |
| 155 | { "-expect-client-ca-list", &TestConfig::expected_client_ca_list }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 156 | }; |
| 157 | |
| 158 | const Flag<std::string> kBase64Flags[] = { |
| 159 | { "-expect-certificate-types", &TestConfig::expected_certificate_types }, |
| 160 | { "-expect-channel-id", &TestConfig::expected_channel_id }, |
| 161 | { "-expect-ocsp-response", &TestConfig::expected_ocsp_response }, |
| 162 | { "-expect-signed-cert-timestamps", |
| 163 | &TestConfig::expected_signed_cert_timestamps }, |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 164 | { "-ocsp-response", &TestConfig::ocsp_response }, |
| 165 | { "-signed-cert-timestamps", &TestConfig::signed_cert_timestamps }, |
Steven Valdez | 909b19f | 2016-11-21 15:35:44 -0500 | [diff] [blame] | 166 | { "-ticket-key", &TestConfig::ticket_key }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 167 | }; |
| 168 | |
| 169 | const Flag<int> kIntFlags[] = { |
Adam Langley | e9ada86 | 2015-05-11 17:20:37 -0700 | [diff] [blame] | 170 | { "-port", &TestConfig::port }, |
David Benjamin | f0c4a6c | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 171 | { "-resume-count", &TestConfig::resume_count }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 172 | { "-min-version", &TestConfig::min_version }, |
| 173 | { "-max-version", &TestConfig::max_version }, |
| 174 | { "-mtu", &TestConfig::mtu }, |
Adam Langley | e9ada86 | 2015-05-11 17:20:37 -0700 | [diff] [blame] | 175 | { "-export-keying-material", &TestConfig::export_keying_material }, |
Kenny Root | e99801b | 2015-11-06 15:31:15 -0800 | [diff] [blame] | 176 | { "-expect-total-renegotiations", &TestConfig::expect_total_renegotiations }, |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 177 | { "-expect-peer-signature-algorithm", |
| 178 | &TestConfig::expect_peer_signature_algorithm }, |
| 179 | { "-expect-curve-id", &TestConfig::expect_curve_id }, |
David Benjamin | d316cba | 2016-06-02 16:17:39 -0400 | [diff] [blame] | 180 | { "-initial-timeout-duration-ms", &TestConfig::initial_timeout_duration_ms }, |
Steven Valdez | bb1ceac | 2016-10-07 10:34:51 -0400 | [diff] [blame] | 181 | { "-max-cert-list", &TestConfig::max_cert_list }, |
Steven Valdez | 909b19f | 2016-11-21 15:35:44 -0500 | [diff] [blame] | 182 | { "-expect-cipher-aes", &TestConfig::expect_cipher_aes }, |
| 183 | { "-expect-cipher-no-aes", &TestConfig::expect_cipher_no_aes }, |
| 184 | { "-resumption-delay", &TestConfig::resumption_delay }, |
Steven Valdez | b0b45c6 | 2017-01-17 16:23:54 -0500 | [diff] [blame] | 185 | { "-max-send-fragment", &TestConfig::max_send_fragment }, |
| 186 | { "-read-size", &TestConfig::read_size }, |
Robert Sloan | 1c9db53 | 2017-03-13 08:03:59 -0700 | [diff] [blame] | 187 | { "-expect-ticket-age-skew", &TestConfig::expect_ticket_age_skew }, |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 188 | }; |
| 189 | |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 190 | const Flag<std::vector<int>> kIntVectorFlags[] = { |
| 191 | { "-signing-prefs", &TestConfig::signing_prefs }, |
Robert Sloan | 572a4e2 | 2017-04-17 10:52:19 -0700 | [diff] [blame] | 192 | { "-verify-prefs", &TestConfig::verify_prefs }, |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 193 | }; |
| 194 | |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 195 | const char kInit[] = "-on-initial"; |
| 196 | const char kResume[] = "-on-resume"; |
| 197 | |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 198 | } // namespace |
| 199 | |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 200 | bool ParseConfig(int argc, char **argv, bool is_resume, |
| 201 | TestConfig *out_config) { |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 202 | for (int i = 0; i < argc; i++) { |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 203 | bool skip = false; |
| 204 | char *flag = argv[i]; |
| 205 | const char *prefix = is_resume ? kResume : kInit; |
| 206 | const char *opposite = is_resume ? kInit : kResume; |
| 207 | if (strncmp(flag, prefix, strlen(prefix)) == 0) { |
| 208 | flag = flag + strlen(prefix); |
| 209 | for (int j = 0; j < argc; j++) { |
| 210 | if (strcmp(argv[j], flag) == 0) { |
| 211 | fprintf(stderr, "Can't use default and prefixed arguments: %s\n", |
| 212 | flag); |
| 213 | return false; |
| 214 | } |
| 215 | } |
| 216 | } else if (strncmp(flag, opposite, strlen(opposite)) == 0) { |
| 217 | flag = flag + strlen(opposite); |
| 218 | skip = true; |
| 219 | } |
| 220 | |
| 221 | bool *bool_field = FindField(out_config, kBoolFlags, flag); |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 222 | if (bool_field != NULL) { |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 223 | if (!skip) { |
| 224 | *bool_field = true; |
| 225 | } |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 226 | continue; |
| 227 | } |
| 228 | |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 229 | std::string *string_field = FindField(out_config, kStringFlags, flag); |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 230 | if (string_field != NULL) { |
| 231 | i++; |
| 232 | if (i >= argc) { |
| 233 | fprintf(stderr, "Missing parameter\n"); |
| 234 | return false; |
| 235 | } |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 236 | if (!skip) { |
| 237 | string_field->assign(argv[i]); |
| 238 | } |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 239 | continue; |
| 240 | } |
| 241 | |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 242 | std::string *base64_field = FindField(out_config, kBase64Flags, flag); |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 243 | if (base64_field != NULL) { |
| 244 | i++; |
| 245 | if (i >= argc) { |
| 246 | fprintf(stderr, "Missing parameter\n"); |
| 247 | return false; |
| 248 | } |
| 249 | size_t len; |
| 250 | if (!EVP_DecodedLength(&len, strlen(argv[i]))) { |
| 251 | fprintf(stderr, "Invalid base64: %s\n", argv[i]); |
David Benjamin | 4969cc9 | 2016-04-22 15:02:23 -0400 | [diff] [blame] | 252 | return false; |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 253 | } |
| 254 | std::unique_ptr<uint8_t[]> decoded(new uint8_t[len]); |
| 255 | if (!EVP_DecodeBase64(decoded.get(), &len, len, |
| 256 | reinterpret_cast<const uint8_t *>(argv[i]), |
| 257 | strlen(argv[i]))) { |
| 258 | fprintf(stderr, "Invalid base64: %s\n", argv[i]); |
David Benjamin | 4969cc9 | 2016-04-22 15:02:23 -0400 | [diff] [blame] | 259 | return false; |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 260 | } |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 261 | if (!skip) { |
| 262 | base64_field->assign(reinterpret_cast<const char *>(decoded.get()), |
| 263 | len); |
| 264 | } |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 265 | continue; |
| 266 | } |
| 267 | |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 268 | int *int_field = FindField(out_config, kIntFlags, flag); |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 269 | if (int_field) { |
| 270 | i++; |
| 271 | if (i >= argc) { |
| 272 | fprintf(stderr, "Missing parameter\n"); |
| 273 | return false; |
| 274 | } |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 275 | if (!skip) { |
| 276 | *int_field = atoi(argv[i]); |
| 277 | } |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 278 | continue; |
| 279 | } |
| 280 | |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 281 | std::vector<int> *int_vector_field = |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 282 | FindField(out_config, kIntVectorFlags, flag); |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 283 | if (int_vector_field) { |
| 284 | i++; |
| 285 | if (i >= argc) { |
| 286 | fprintf(stderr, "Missing parameter\n"); |
| 287 | return false; |
| 288 | } |
| 289 | |
| 290 | // Each instance of the flag adds to the list. |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 291 | if (!skip) { |
| 292 | int_vector_field->push_back(atoi(argv[i])); |
| 293 | } |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 294 | continue; |
| 295 | } |
| 296 | |
Robert Sloan | 8ff0355 | 2017-06-14 12:40:58 -0700 | [diff] [blame^] | 297 | fprintf(stderr, "Unknown argument: %s\n", flag); |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 298 | return false; |
| 299 | } |
| 300 | |
| 301 | return true; |
| 302 | } |