1 /* 2 * Copyright (c) 2020, The OpenThread Authors. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 3. Neither the name of the copyright holder nor the 13 * names of its contributors may be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 /** 30 * @file 31 * This file includes compile-time configurations for the SRP (Service Registration Protocol) Client. 32 * 33 */ 34 35 #ifndef CONFIG_SRP_CLIENT_H_ 36 #define CONFIG_SRP_CLIENT_H_ 37 38 /** 39 * @def OPENTHREAD_CONFIG_SRP_CLIENT_ENABLE 40 * 41 * Define to 1 to enable SRP Client support. 42 * 43 */ 44 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_ENABLE 45 #define OPENTHREAD_CONFIG_SRP_CLIENT_ENABLE 0 46 #endif 47 48 /** 49 * @def OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE 50 * 51 * Define to 1 to enable SRP Client auto-start feature and its APIs. 52 * 53 * When enabled, the SRP client can be configured to automatically start when it detects the presence of an SRP server 54 * (by monitoring the Thread Network Data for SRP Server Service entries). 55 * 56 */ 57 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE 58 #define OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE 1 59 #endif 60 61 /** 62 * @def OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_DEFAULT_MODE 63 * 64 * Define the default mode (enabled or disabled) of auto-start mode. 65 * 66 * This config is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled. 67 * 68 */ 69 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_DEFAULT_MODE 70 #define OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_DEFAULT_MODE 0 71 #endif 72 73 /** 74 * @def OPENTHREAD_CONFIG_SRP_CLIENT_SWITCH_SERVER_ON_FAILURE 75 * 76 * Define to 1 to enable SRP client to switch server on failure (when auto-start feature is used). 77 * 78 * This config is only used when `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled. 79 * 80 * When enabled, the client will try to select the next server from entries in Thread Network Data when the current 81 * server rejects an SRP update or there is no response (timeout waiting for response from server). 82 * 83 */ 84 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_SWITCH_SERVER_ON_FAILURE 85 #define OPENTHREAD_CONFIG_SRP_CLIENT_SWITCH_SERVER_ON_FAILURE 1 86 #endif 87 88 /** 89 * @def OPENTHREAD_CONFIG_SRP_CLIENT_DISALLOW_SERVER_SWITCH_WITH_REGISTERED_HOST 90 * 91 * Define to 1 to disallow SRP client to switch server (when auto-start is used) on failure if host (or any services) 92 * were previously successfully registered with the currently selected server. 93 * 94 * This config is only applicable when `OPENTHREAD_CONFIG_SRP_CLIENT_SWITCH_SERVER_ON_FAILURE` is enabled. 95 * 96 * If this is enabled, once SRP client successfully registers with an auto-start selected SRP server, it stays with 97 * the selected SRP server (even if future SRP updates fail or timeout) while the related server entry remains present 98 * in the Thread Network Data. If the entry is removed from Network Data, then SRP client will try to select a new 99 * server. 100 * 101 * Enabling this behavior would be useful allowing more aggressive switch logic (e.g., switch after fewer timeouts 102 * `OPENTHREAD_CONFIG_SRP_CLIENT_MAX_TIMEOUT_FAILURES_TO_SWITCH_SERVER`) while not allowing switch due to temporary 103 * failures on the currently selected server. This can help avoid situation where the old server may still remember the 104 * registered host/service info and client switching to a new server then failing due to name conflict (when new server 105 * probes for the host/service name original server would not allow new registration). 106 * 107 */ 108 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_DISALLOW_SERVER_SWITCH_WITH_REGISTERED_HOST 109 #define OPENTHREAD_CONFIG_SRP_CLIENT_DISALLOW_SERVER_SWITCH_WITH_REGISTERED_HOST 1 110 #endif 111 112 /** 113 * @def OPENTHREAD_CONFIG_SRP_CLIENT_MAX_TIMEOUT_FAILURES_TO_SWITCH_SERVER 114 * 115 * Specifies number of timeout failures to trigger a switch of server. 116 * 117 * This is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_SWITCH_SERVER_ON_FAILURE` is used. 118 * 119 */ 120 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_MAX_TIMEOUT_FAILURES_TO_SWITCH_SERVER 121 #define OPENTHREAD_CONFIG_SRP_CLIENT_MAX_TIMEOUT_FAILURES_TO_SWITCH_SERVER 3 122 #endif 123 124 /** 125 * @def OPENTHREAD_CONFIG_SRP_CLIENT_DOMAIN_NAME_API_ENABLE 126 * 127 * Define to 1 for the SRP client implementation to provide APIs that get/set the domain name. 128 * 129 */ 130 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_DOMAIN_NAME_API_ENABLE 131 #define OPENTHREAD_CONFIG_SRP_CLIENT_DOMAIN_NAME_API_ENABLE 0 132 #endif 133 134 /** 135 * @def OPENTHREAD_CONFIG_SRP_CLIENT_SAVE_SELECTED_SERVER_ENABLE 136 * 137 * Define to 1 to enable SRP client feature to save the selected server in non-volatile settings. 138 * 139 * When enabled, the SRP client will save the selected server info by auto-start feature in the non-volatile settings 140 * and on a client restart (e.g., due to a device reset) it will select the same server when searching to discover and 141 * pick one from the Thread Network Data service entries. The server info is saved only after the host info is 142 * successfully registered with the server and if it is selected by auto-start from a network data SRP *unicast* 143 * service entry. 144 * 145 */ 146 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_SAVE_SELECTED_SERVER_ENABLE 147 #define OPENTHREAD_CONFIG_SRP_CLIENT_SAVE_SELECTED_SERVER_ENABLE 1 148 #endif 149 150 /** 151 * @def OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_LEASE 152 * 153 * Specifies the default requested lease interval (in seconds). Set to two hours. 154 * 155 */ 156 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_LEASE 157 #define OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_LEASE (2 * 60 * 60) 158 #endif 159 160 /** 161 * @def OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_KEY_LEASE 162 * 163 * Specifies the default requested key lease interval (in seconds). Set to 14 days. 164 * 165 */ 166 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_KEY_LEASE 167 #define OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_KEY_LEASE (14 * 24 * 60 * 60) 168 #endif 169 170 /** 171 * @def OPENTHREAD_CONFIG_SRP_CLIENT_LEASE_RENEW_GUARD_INTERVAL 172 * 173 * Specifies the guard interval (in seconds) for lease renew time. The guard interval determines how much earlier 174 * (relative to the lease expiration time) the SRP client will send an SRP update for lease renewal. 175 * 176 */ 177 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_LEASE_RENEW_GUARD_INTERVAL 178 #define OPENTHREAD_CONFIG_SRP_CLIENT_LEASE_RENEW_GUARD_INTERVAL 120 // two minutes in seconds 179 #endif 180 181 /** 182 * @def OPENTHREAD_CONFIG_SRP_CLIENT_EARLY_LEASE_RENEW_FACTOR_NUMERATOR 183 * 184 * Specifies the numerator of early lease renewal factor. 185 * 186 * This value is used for opportunistic early refresh behave. When sending an SRP update, the services that are not yet 187 * expired but are close, are allowed to refresh early and are included in the SRP update. 188 * 189 * The "early lease renewal interval" is used to determine if a service can renew early. The interval is calculated by 190 * multiplying the accepted lease interval by the "early lease renewal factor" which is given as a fraction (numerator 191 * and denominator). 192 * 193 * If the factor is set to zero (numerator=0, denominator=1), the opportunistic early refresh behavior is disabled. 194 * If denominator is set to zero (the factor is set to infinity), then all services (including previously registered 195 * ones) are always included in SRP update message. 196 * 197 * Default value is 1/2 (i.e., services that are within half of the lease interval are allowed to refresh early). 198 * 199 */ 200 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_EARLY_LEASE_RENEW_FACTOR_NUMERATOR 201 #define OPENTHREAD_CONFIG_SRP_CLIENT_EARLY_LEASE_RENEW_FACTOR_NUMERATOR 1 202 #endif 203 204 /** 205 * @def OPENTHREAD_CONFIG_SRP_CLIENT_EARLY_LEASE_RENEW_FACTOR_DENOMINATOR 206 * 207 * Specifies the denominator of early lease renewal factor. 208 * 209 * Please see OPENTHREAD_CONFIG_SRP_CLIENT_EARLY_LEASE_RENEW_FACTOR_NUMERATOR for more details. 210 * 211 */ 212 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_EARLY_LEASE_RENEW_FACTOR_DENOMINATOR 213 #define OPENTHREAD_CONFIG_SRP_CLIENT_EARLY_LEASE_RENEW_FACTOR_DENOMINATOR 2 214 #endif 215 216 /** 217 * @def OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MIN_DELAY 218 * 219 * Specifies the minimum value (in msec) for the short random delay wait time before sending an update message. 220 * 221 * The random delay is chosen uniformly from the min up to max value `OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MAX_DELAY`. 222 * 223 * When there is a change (e.g., a new service is added/removed) that requires an update, the SRP client will wait for 224 * a short delay before preparing and sending an SRP update message to server. This allows user to provide more change 225 * that are then all sent in same update message. The delay is only applied on the first change that triggers an 226 * update message transmission. Subsequent changes (API calls) while waiting for the tx to start will not reset the 227 * delay timer. 228 * 229 */ 230 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MIN_DELAY 231 #define OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MIN_DELAY 10 232 #endif 233 234 /** 235 * @def OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MIN_DELAY 236 * 237 * Specifies the maximum value (in msec) for the short random delay wait time before sending an update message. 238 * 239 * The random delay is chosen uniformly from the min `OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MIN_DELAY` up to max value. 240 * 241 * See `OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MIN_DELAY` for more details. 242 * 243 */ 244 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MAX_DELAY 245 #define OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_MAX_DELAY 700 246 #endif 247 248 /** 249 * @def OPENTHREAD_CONFIG_SRP_CLIENT_MIN_RETRY_WAIT_INTERVAL 250 * 251 * Specifies the minimum wait interval (in msec) between SRP update message retries. 252 * 253 * The update message is retransmitted if there is no response from server or if server rejects the update. The wait 254 * interval starts from the minimum value and is increased by the growth factor every failure up to the max value. 255 * 256 */ 257 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_MIN_RETRY_WAIT_INTERVAL 258 #define OPENTHREAD_CONFIG_SRP_CLIENT_MIN_RETRY_WAIT_INTERVAL 1800 259 #endif 260 261 /** 262 * @def OPENTHREAD_CONFIG_SRP_CLIENT_MAX_RETRY_WAIT_INTERVAL 263 * 264 * Specifies the maximum wait interval (in msec) between SRP update message retries. 265 * 266 */ 267 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_MAX_RETRY_WAIT_INTERVAL 268 #define OPENTHREAD_CONFIG_SRP_CLIENT_MAX_RETRY_WAIT_INTERVAL (1 * 60 * 60 * 1000) // 1 hour in ms. 269 #endif 270 271 /** 272 * @def OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_WAIT_INTERVAL_JITTER 273 * 274 * Specifies jitter (in msec) for retry wait interval. If the current retry wait interval is smaller than the jitter 275 * then the the wait interval itself is used as jitter (e.g., with jitter 500 msec and if retry interval is 300ms 276 * the retry interval is then randomly selected from [0, 2*300] ms). 277 * 278 */ 279 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_WAIT_INTERVAL_JITTER 280 #define OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_WAIT_INTERVAL_JITTER 500 281 #endif 282 283 /** 284 * @def OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_INTERVAL_GROWTH_FACTOR_NUMERATOR 285 * 286 * Specifies the numerator of the retry wait interval growth factor fraction. The growth factor is represented as 287 * a fraction (e.g., for 1.5, we can use 15 as the numerator and 10 as the denominator). 288 * 289 */ 290 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_INTERVAL_GROWTH_FACTOR_NUMERATOR 291 #define OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_INTERVAL_GROWTH_FACTOR_NUMERATOR 17 292 #endif 293 294 /** 295 * @def OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_INTERVAL_GROWTH_FACTOR_DENOMINATOR 296 * 297 * Specifies the denominator of the retry wait interval growth factor fraction. 298 * 299 */ 300 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_INTERVAL_GROWTH_FACTOR_DENOMINATOR 301 #define OPENTHREAD_CONFIG_SRP_CLIENT_RETRY_INTERVAL_GROWTH_FACTOR_DENOMINATOR 10 302 #endif 303 304 /** 305 * @def OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE 306 * 307 * Define to 1 to enable SRP Client buffers and service pool feature. 308 * 309 */ 310 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE 311 #define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE OPENTHREAD_CONFIG_SRP_CLIENT_ENABLE 312 #endif 313 314 /** 315 * @def OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_MAX_SERVICES 316 * 317 * Specifies number of service entries in the SRP client service pool. 318 * 319 * This config is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE` is enabled. 320 * 321 */ 322 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_MAX_SERVICES 323 #define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_MAX_SERVICES 2 324 #endif 325 326 /** 327 * @def OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_MAX_HOST_ADDRESSES 328 * 329 * Specifies number of host IPv6 address entries in the SRP client buffers and service pool. 330 * 331 * This config is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE` is enabled. 332 * 333 */ 334 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_MAX_HOST_ADDRESSES 335 #define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_MAX_HOST_ADDRESSES 2 336 #endif 337 338 /** 339 * @def OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_HOST_NAME_SIZE 340 * 341 * Specifies the size (number of chars) of host name string buffer in the SRP client buffers and service pool. 342 * 343 * This config is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE` is enabled. 344 * 345 */ 346 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_HOST_NAME_SIZE 347 #define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_HOST_NAME_SIZE 64 348 #endif 349 350 /** 351 * @def OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_NAME_SIZE 352 * 353 * Specifies the size (number of chars) of service name string buffer in the SRP client buffers and service pool. 354 * 355 * This config is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE` is enabled. 356 * 357 */ 358 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_NAME_SIZE 359 #define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_NAME_SIZE 96 360 #endif 361 362 /** 363 * @def OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_MAX_SUB_TYPES 364 * 365 * Specifies the maximum number of service subtype labels (array length) in the SRP client buffers and service pool. 366 * 367 * This config is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE` is enabled. 368 * 369 */ 370 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_MAX_SUB_TYPES 371 #define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_MAX_SUB_TYPES 6 372 #endif 373 374 /** 375 * @def OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_INSTANCE_NAME_SIZE 376 * 377 * Specifies the size (number of chars) of service instance name string buffer in the SRP client buffers and service 378 * pool. 379 * 380 * This config is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE` is enabled. 381 * 382 */ 383 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_INSTANCE_NAME_SIZE 384 #define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_SERVICE_INSTANCE_NAME_SIZE 64 385 #endif 386 387 /** 388 * @def OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_TXT_BUFFER_SIZE 389 * 390 * Specifies the size (number of bytes) of TXT record value buffer in the SRP client buffers and service pool. 391 * 392 * This config is applicable only when `OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_ENABLE` is enabled. 393 * 394 */ 395 #ifndef OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_TXT_BUFFER_SIZE 396 #define OPENTHREAD_CONFIG_SRP_CLIENT_BUFFERS_TXT_BUFFER_SIZE 64 397 #endif 398 399 #endif // CONFIG_SRP_CLIENT_H_ 400