Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 1 | /* |
| 2 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 3 | * Copyright 2015 gRPC authors. |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 4 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 8 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 10 | * |
Jan Tattermusch | 7897ae9 | 2017-06-07 22:57:36 +0200 | [diff] [blame] | 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 16 | * |
| 17 | */ |
| 18 | |
Craig Tiller | 9eb0fde | 2017-03-31 16:59:30 -0700 | [diff] [blame] | 19 | #include "src/core/ext/filters/client_channel/uri_parser.h" |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 20 | |
| 21 | #include <string.h> |
| 22 | |
Craig Tiller | 0f31080 | 2016-10-26 16:25:56 -0700 | [diff] [blame] | 23 | #include <grpc/slice_buffer.h> |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 24 | #include <grpc/support/alloc.h> |
| 25 | #include <grpc/support/log.h> |
yang-g | b063c87 | 2015-10-07 11:40:13 -0700 | [diff] [blame] | 26 | #include <grpc/support/port_platform.h> |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 27 | #include <grpc/support/string_util.h> |
| 28 | |
Yuchen Zeng | aa76d3d | 2017-02-15 14:00:01 -0800 | [diff] [blame] | 29 | #include "src/core/lib/slice/percent_encoding.h" |
Yuchen Zeng | c40d1d8 | 2017-02-15 20:42:06 -0800 | [diff] [blame] | 30 | #include "src/core/lib/slice/slice_internal.h" |
| 31 | #include "src/core/lib/slice/slice_string_helpers.h" |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 32 | #include "src/core/lib/support/string.h" |
| 33 | |
Craig Tiller | f29a388 | 2015-09-11 12:59:27 -0700 | [diff] [blame] | 34 | /** a size_t default value... maps to all 1's */ |
| 35 | #define NOT_SET (~(size_t)0) |
| 36 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 37 | static grpc_uri* bad_uri(const char* uri_text, size_t pos, const char* section, |
David Garcia Quintas | 53af23c | 2017-04-15 10:29:46 -0700 | [diff] [blame] | 38 | bool suppress_errors) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 39 | char* line_prefix; |
Craig Tiller | 3121fd4 | 2015-09-10 09:56:20 -0700 | [diff] [blame] | 40 | size_t pfx_len; |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 41 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 42 | if (!suppress_errors) { |
| 43 | gpr_asprintf(&line_prefix, "bad uri.%s: '", section); |
| 44 | pfx_len = strlen(line_prefix) + pos; |
| 45 | gpr_log(GPR_ERROR, "%s%s'", line_prefix, uri_text); |
| 46 | gpr_free(line_prefix); |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 47 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 48 | line_prefix = (char*)gpr_malloc(pfx_len + 1); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 49 | memset(line_prefix, ' ', pfx_len); |
| 50 | line_prefix[pfx_len] = 0; |
| 51 | gpr_log(GPR_ERROR, "%s^ here", line_prefix); |
| 52 | gpr_free(line_prefix); |
| 53 | } |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 54 | |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 55 | return nullptr; |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 56 | } |
| 57 | |
Yuchen Zeng | aa76d3d | 2017-02-15 14:00:01 -0800 | [diff] [blame] | 58 | /** Returns a copy of percent decoded \a src[begin, end) */ |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 59 | static char* decode_and_copy_component(grpc_exec_ctx* exec_ctx, const char* src, |
Yuchen Zeng | c40d1d8 | 2017-02-15 20:42:06 -0800 | [diff] [blame] | 60 | size_t begin, size_t end) { |
Yuchen Zeng | aa76d3d | 2017-02-15 14:00:01 -0800 | [diff] [blame] | 61 | grpc_slice component = |
ncteisen | 5dd0d6f | 2017-11-07 17:18:55 -0800 | [diff] [blame] | 62 | (begin == NOT_SET || end == NOT_SET) |
| 63 | ? grpc_empty_slice() |
| 64 | : grpc_slice_from_copied_buffer(src + begin, end - begin); |
Yuchen Zeng | aa76d3d | 2017-02-15 14:00:01 -0800 | [diff] [blame] | 65 | grpc_slice decoded_component = |
| 66 | grpc_permissive_percent_decode_slice(component); |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 67 | char* out = grpc_dump_slice(decoded_component, GPR_DUMP_ASCII); |
Yuchen Zeng | c40d1d8 | 2017-02-15 20:42:06 -0800 | [diff] [blame] | 68 | grpc_slice_unref_internal(exec_ctx, component); |
| 69 | grpc_slice_unref_internal(exec_ctx, decoded_component); |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 70 | return out; |
| 71 | } |
| 72 | |
Igor Pylypiv | 282c139 | 2017-04-04 19:44:06 -0700 | [diff] [blame] | 73 | static bool valid_hex(char c) { |
| 74 | return ((c >= 'a') && (c <= 'f')) || ((c >= 'A') && (c <= 'F')) || |
| 75 | ((c >= '0') && (c <= '9')); |
| 76 | } |
| 77 | |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 78 | /** Returns how many chars to advance if \a uri_text[i] begins a valid \a pchar |
| 79 | * production. If \a uri_text[i] introduces an invalid \a pchar (such as percent |
Craig Tiller | f29a388 | 2015-09-11 12:59:27 -0700 | [diff] [blame] | 80 | * sign not followed by two hex digits), NOT_SET is returned. */ |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 81 | static size_t parse_pchar(const char* uri_text, size_t i) { |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 82 | /* pchar = unreserved / pct-encoded / sub-delims / ":" / "@" |
| 83 | * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~" |
| 84 | * pct-encoded = "%" HEXDIG HEXDIG |
| 85 | * sub-delims = "!" / "$" / "&" / "'" / "(" / ")" |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 86 | / "*" / "+" / "," / ";" / "=" */ |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 87 | char c = uri_text[i]; |
Igor Pylypiv | 282c139 | 2017-04-04 19:44:06 -0700 | [diff] [blame] | 88 | switch (c) { |
| 89 | default: |
| 90 | if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || |
| 91 | ((c >= '0') && (c <= '9'))) { |
| 92 | return 1; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 93 | } |
Igor Pylypiv | 282c139 | 2017-04-04 19:44:06 -0700 | [diff] [blame] | 94 | break; |
| 95 | case ':': |
| 96 | case '@': |
| 97 | case '-': |
| 98 | case '.': |
| 99 | case '_': |
| 100 | case '~': |
| 101 | case '!': |
| 102 | case '$': |
| 103 | case '&': |
| 104 | case '\'': |
| 105 | case '(': |
| 106 | case ')': |
| 107 | case '*': |
| 108 | case '+': |
| 109 | case ',': |
| 110 | case ';': |
| 111 | case '=': |
| 112 | return 1; |
| 113 | case '%': /* pct-encoded */ |
| 114 | if (valid_hex(uri_text[i + 1]) && valid_hex(uri_text[i + 2])) { |
| 115 | return 2; |
| 116 | } |
| 117 | return NOT_SET; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 118 | } |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 119 | return 0; |
| 120 | } |
| 121 | |
| 122 | /* *( pchar / "?" / "/" ) */ |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 123 | static int parse_fragment_or_query(const char* uri_text, size_t* i) { |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 124 | char c; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 125 | while ((c = uri_text[*i]) != 0) { |
| 126 | const size_t advance = parse_pchar(uri_text, *i); /* pchar */ |
| 127 | switch (advance) { |
| 128 | case 0: /* uri_text[i] isn't in pchar */ |
| 129 | /* maybe it's ? or / */ |
| 130 | if (uri_text[*i] == '?' || uri_text[*i] == '/') { |
| 131 | (*i)++; |
| 132 | break; |
| 133 | } else { |
| 134 | return 1; |
| 135 | } |
yang-g | b063c87 | 2015-10-07 11:40:13 -0700 | [diff] [blame] | 136 | GPR_UNREACHABLE_CODE(return 0); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 137 | default: |
| 138 | (*i) += advance; |
| 139 | break; |
| 140 | case NOT_SET: /* uri_text[i] introduces an invalid URI */ |
| 141 | return 0; |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 142 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 143 | } |
Craig Tiller | f29a388 | 2015-09-11 12:59:27 -0700 | [diff] [blame] | 144 | /* *i is the first uri_text position past the \a query production, maybe \0 */ |
| 145 | return 1; |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 146 | } |
| 147 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 148 | static void parse_query_parts(grpc_uri* uri) { |
| 149 | static const char* QUERY_PARTS_SEPARATOR = "&"; |
| 150 | static const char* QUERY_PARTS_VALUE_SEPARATOR = "="; |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 151 | GPR_ASSERT(uri->query != nullptr); |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 152 | if (uri->query[0] == '\0') { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 153 | uri->query_parts = nullptr; |
| 154 | uri->query_parts_values = nullptr; |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 155 | uri->num_query_parts = 0; |
| 156 | return; |
| 157 | } |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 158 | |
Craig Tiller | 87a7e1f | 2016-11-09 09:42:19 -0800 | [diff] [blame] | 159 | gpr_string_split(uri->query, QUERY_PARTS_SEPARATOR, &uri->query_parts, |
| 160 | &uri->num_query_parts); |
Yash Tibrewal | ca3c1c0 | 2017-09-07 22:47:16 -0700 | [diff] [blame] | 161 | uri->query_parts_values = |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 162 | (char**)gpr_malloc(uri->num_query_parts * sizeof(char**)); |
Craig Tiller | 87a7e1f | 2016-11-09 09:42:19 -0800 | [diff] [blame] | 163 | for (size_t i = 0; i < uri->num_query_parts; i++) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 164 | char** query_param_parts; |
Craig Tiller | 87a7e1f | 2016-11-09 09:42:19 -0800 | [diff] [blame] | 165 | size_t num_query_param_parts; |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 166 | char* full = uri->query_parts[i]; |
Craig Tiller | 87a7e1f | 2016-11-09 09:42:19 -0800 | [diff] [blame] | 167 | gpr_string_split(full, QUERY_PARTS_VALUE_SEPARATOR, &query_param_parts, |
| 168 | &num_query_param_parts); |
| 169 | GPR_ASSERT(num_query_param_parts > 0); |
| 170 | uri->query_parts[i] = query_param_parts[0]; |
| 171 | if (num_query_param_parts > 1) { |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 172 | /* TODO(dgq): only the first value after the separator is considered. |
| 173 | * Perhaps all chars after the first separator for the query part should |
| 174 | * be included, even if they include the separator. */ |
Craig Tiller | 87a7e1f | 2016-11-09 09:42:19 -0800 | [diff] [blame] | 175 | uri->query_parts_values[i] = query_param_parts[1]; |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 176 | } else { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 177 | uri->query_parts_values[i] = nullptr; |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 178 | } |
Craig Tiller | 87a7e1f | 2016-11-09 09:42:19 -0800 | [diff] [blame] | 179 | for (size_t j = 2; j < num_query_param_parts; j++) { |
| 180 | gpr_free(query_param_parts[j]); |
| 181 | } |
| 182 | gpr_free(query_param_parts); |
| 183 | gpr_free(full); |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 184 | } |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 185 | } |
| 186 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 187 | grpc_uri* grpc_uri_parse(grpc_exec_ctx* exec_ctx, const char* uri_text, |
David Garcia Quintas | 53af23c | 2017-04-15 10:29:46 -0700 | [diff] [blame] | 188 | bool suppress_errors) { |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 189 | grpc_uri* uri; |
Craig Tiller | 3121fd4 | 2015-09-10 09:56:20 -0700 | [diff] [blame] | 190 | size_t scheme_begin = 0; |
Craig Tiller | 3121fd4 | 2015-09-10 09:56:20 -0700 | [diff] [blame] | 191 | size_t scheme_end = NOT_SET; |
| 192 | size_t authority_begin = NOT_SET; |
| 193 | size_t authority_end = NOT_SET; |
| 194 | size_t path_begin = NOT_SET; |
| 195 | size_t path_end = NOT_SET; |
Craig Tiller | f29a388 | 2015-09-11 12:59:27 -0700 | [diff] [blame] | 196 | size_t query_begin = NOT_SET; |
| 197 | size_t query_end = NOT_SET; |
| 198 | size_t fragment_begin = NOT_SET; |
| 199 | size_t fragment_end = NOT_SET; |
Craig Tiller | 3121fd4 | 2015-09-10 09:56:20 -0700 | [diff] [blame] | 200 | size_t i; |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 201 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 202 | for (i = scheme_begin; uri_text[i] != 0; i++) { |
| 203 | if (uri_text[i] == ':') { |
| 204 | scheme_end = i; |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 205 | break; |
| 206 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 207 | if (uri_text[i] >= 'a' && uri_text[i] <= 'z') continue; |
| 208 | if (uri_text[i] >= 'A' && uri_text[i] <= 'Z') continue; |
| 209 | if (i != scheme_begin) { |
| 210 | if (uri_text[i] >= '0' && uri_text[i] <= '9') continue; |
| 211 | if (uri_text[i] == '+') continue; |
| 212 | if (uri_text[i] == '-') continue; |
| 213 | if (uri_text[i] == '.') continue; |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 214 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 215 | break; |
| 216 | } |
| 217 | if (scheme_end == NOT_SET) { |
| 218 | return bad_uri(uri_text, i, "scheme", suppress_errors); |
| 219 | } |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 220 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 221 | if (uri_text[scheme_end + 1] == '/' && uri_text[scheme_end + 2] == '/') { |
| 222 | authority_begin = scheme_end + 3; |
| 223 | for (i = authority_begin; uri_text[i] != 0 && authority_end == NOT_SET; |
| 224 | i++) { |
| 225 | if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#') { |
| 226 | authority_end = i; |
| 227 | } |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 228 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 229 | if (authority_end == NOT_SET && uri_text[i] == 0) { |
| 230 | authority_end = i; |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 231 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 232 | if (authority_end == NOT_SET) { |
| 233 | return bad_uri(uri_text, i, "authority", suppress_errors); |
| 234 | } |
| 235 | /* TODO(ctiller): parse the authority correctly */ |
| 236 | path_begin = authority_end; |
| 237 | } else { |
| 238 | path_begin = scheme_end + 1; |
| 239 | } |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 240 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 241 | for (i = path_begin; uri_text[i] != 0; i++) { |
| 242 | if (uri_text[i] == '?' || uri_text[i] == '#') { |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 243 | path_end = i; |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 244 | break; |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 245 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 246 | } |
| 247 | if (path_end == NOT_SET && uri_text[i] == 0) { |
| 248 | path_end = i; |
| 249 | } |
| 250 | if (path_end == NOT_SET) { |
| 251 | return bad_uri(uri_text, i, "path", suppress_errors); |
| 252 | } |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 253 | |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 254 | if (uri_text[i] == '?') { |
| 255 | query_begin = ++i; |
| 256 | if (!parse_fragment_or_query(uri_text, &i)) { |
| 257 | return bad_uri(uri_text, i, "query", suppress_errors); |
| 258 | } else if (uri_text[i] != 0 && uri_text[i] != '#') { |
| 259 | /* We must be at the end or at the beginning of a fragment */ |
| 260 | return bad_uri(uri_text, i, "query", suppress_errors); |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 261 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 262 | query_end = i; |
| 263 | } |
| 264 | if (uri_text[i] == '#') { |
| 265 | fragment_begin = ++i; |
| 266 | if (!parse_fragment_or_query(uri_text, &i)) { |
| 267 | return bad_uri(uri_text, i - fragment_end, "fragment", suppress_errors); |
| 268 | } else if (uri_text[i] != 0) { |
| 269 | /* We must be at the end */ |
| 270 | return bad_uri(uri_text, i, "fragment", suppress_errors); |
David Garcia Quintas | 5267891 | 2015-09-07 11:28:58 -0700 | [diff] [blame] | 271 | } |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 272 | fragment_end = i; |
| 273 | } |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 274 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 275 | uri = (grpc_uri*)gpr_zalloc(sizeof(*uri)); |
Yuchen Zeng | c40d1d8 | 2017-02-15 20:42:06 -0800 | [diff] [blame] | 276 | uri->scheme = |
| 277 | decode_and_copy_component(exec_ctx, uri_text, scheme_begin, scheme_end); |
| 278 | uri->authority = decode_and_copy_component(exec_ctx, uri_text, |
| 279 | authority_begin, authority_end); |
| 280 | uri->path = |
| 281 | decode_and_copy_component(exec_ctx, uri_text, path_begin, path_end); |
| 282 | uri->query = |
| 283 | decode_and_copy_component(exec_ctx, uri_text, query_begin, query_end); |
| 284 | uri->fragment = decode_and_copy_component(exec_ctx, uri_text, fragment_begin, |
| 285 | fragment_end); |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 286 | parse_query_parts(uri); |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 287 | |
| 288 | return uri; |
| 289 | } |
| 290 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 291 | const char* grpc_uri_get_query_arg(const grpc_uri* uri, const char* key) { |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 292 | GPR_ASSERT(key != nullptr); |
| 293 | if (key[0] == '\0') return nullptr; |
David Garcia Quintas | 057054f | 2016-03-31 09:20:42 -0700 | [diff] [blame] | 294 | |
| 295 | for (size_t i = 0; i < uri->num_query_parts; ++i) { |
| 296 | if (0 == strcmp(key, uri->query_parts[i])) { |
| 297 | return uri->query_parts_values[i]; |
| 298 | } |
| 299 | } |
Craig Tiller | 4782d92 | 2017-11-10 09:53:21 -0800 | [diff] [blame] | 300 | return nullptr; |
David Garcia Quintas | 057054f | 2016-03-31 09:20:42 -0700 | [diff] [blame] | 301 | } |
| 302 | |
Craig Tiller | baa14a9 | 2017-11-03 09:09:36 -0700 | [diff] [blame] | 303 | void grpc_uri_destroy(grpc_uri* uri) { |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 304 | if (!uri) return; |
| 305 | gpr_free(uri->scheme); |
| 306 | gpr_free(uri->authority); |
| 307 | gpr_free(uri->path); |
| 308 | gpr_free(uri->query); |
David Garcia Quintas | e3a49f8 | 2016-03-30 17:19:29 -0700 | [diff] [blame] | 309 | for (size_t i = 0; i < uri->num_query_parts; ++i) { |
| 310 | gpr_free(uri->query_parts[i]); |
| 311 | gpr_free(uri->query_parts_values[i]); |
| 312 | } |
| 313 | gpr_free(uri->query_parts); |
| 314 | gpr_free(uri->query_parts_values); |
Craig Tiller | a82950e | 2015-09-22 12:33:20 -0700 | [diff] [blame] | 315 | gpr_free(uri->fragment); |
| 316 | gpr_free(uri); |
Craig Tiller | 3bc8ebd | 2015-06-24 15:41:15 -0700 | [diff] [blame] | 317 | } |