mDNSMacOSX/dnssd_xpc.c

   1 /*
   2  * Copyright (c) 2019 Apple Inc. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "dnssd_xpc.h"
  18
  19 #if 0
  20 //======================================================================================================================
  21 #pragma mark - XPC Dictionary Helper Declarations
  22 #endif
  23
  24 static int32_t
  25 _dnssd_xpc_dictionary_get_int32(xpc_object_t dict, const char *key, bool *out_valid);
  26
  27 static int64_t
  28 _dnssd_xpc_dictionary_get_int64(xpc_object_t dict, const char *key, bool *out_valid);
  29
  30 static int64_t
  31 _dnssd_xpc_dictionary_get_int64_limited(xpc_object_t dict, const char *key, int64_t min, int64_t max, bool *out_valid);
  32
  33 static uint16_t
  34 _dnssd_xpc_dictionary_get_uint16(xpc_object_t dict, const char *key, bool *out_valid);
  35
  36 static uint32_t
  37 _dnssd_xpc_dictionary_get_uint32(xpc_object_t dict, const char *key, bool *out_valid);
  38
  39 static uint64_t
  40 _dnssd_xpc_dictionary_get_uint64(xpc_object_t dict, const char *key, bool *out_valid);
  41
  42 static uint64_t
  43 _dnssd_xpc_dictionary_get_uint64_limited(xpc_object_t dict, const char *key, uint64_t min, uint64_t max,
  44         bool *out_valid);
  45
  46 static xpc_object_t
  47 _dnssd_xpc_dictionary_get_value(xpc_object_t dict, const char *key, xpc_type_t type);
  48
  49 #if 0
  50 //======================================================================================================================
  51 #pragma mark - Top-Level Message Dictionaries
  52 #endif
  53
  54 #define DNSSD_XPC_MESSAGE_KEY_COMMAND   "command"
  55 #define DNSSD_XPC_MESSAGE_KEY_ERROR             "error"
  56 #define DNSSD_XPC_MESSAGE_KEY_ID                "id"
  57 #define DNSSD_XPC_MESSAGE_KEY_PARAMS    "params"
  58 #define DNSSD_XPC_MESSAGE_KEY_RESULTS   "results"
  59
  60 //======================================================================================================================
  61
  62 const char *
  63 dnssd_xpc_message_get_command(xpc_object_t msg)
  64 {
  65         return xpc_dictionary_get_string(msg, DNSSD_XPC_MESSAGE_KEY_COMMAND);
  66 }
  67
  68 //======================================================================================================================
  69
  70 void
  71 dnssd_xpc_message_set_command(xpc_object_t msg, const char *command)
  72 {
  73         xpc_dictionary_set_string(msg, DNSSD_XPC_MESSAGE_KEY_COMMAND, command);
  74 }
  75
  76 //======================================================================================================================
  77
  78 DNSServiceErrorType
  79 dnssd_xpc_message_get_error(xpc_object_t msg, bool *out_valid)
  80 {
  81         return _dnssd_xpc_dictionary_get_int32(msg, DNSSD_XPC_MESSAGE_KEY_ERROR, out_valid);
  82 }
  83
  84 //======================================================================================================================
  85
  86 void
  87 dnssd_xpc_message_set_error(xpc_object_t msg, DNSServiceErrorType error)
  88 {
  89         xpc_dictionary_set_int64(msg, DNSSD_XPC_MESSAGE_KEY_ERROR, error);
  90 }
  91
  92 //======================================================================================================================
  93
  94 uint64_t
  95 dnssd_xpc_message_get_id(xpc_object_t msg, bool *out_valid)
  96 {
  97         return _dnssd_xpc_dictionary_get_uint64(msg, DNSSD_XPC_MESSAGE_KEY_ID, out_valid);
  98 }
  99
 100 //======================================================================================================================
 101
 102 void
 103 dnssd_xpc_message_set_id(xpc_object_t msg, uint64_t ident)
 104 {
 105         xpc_dictionary_set_uint64(msg, DNSSD_XPC_MESSAGE_KEY_ID, ident);
 106 }
 107
 108 //======================================================================================================================
 109
 110 xpc_object_t
 111 dnssd_xpc_message_get_parameters(xpc_object_t msg)
 112 {
 113         return xpc_dictionary_get_dictionary(msg, DNSSD_XPC_MESSAGE_KEY_PARAMS);
 114 }
 115
 116 //======================================================================================================================
 117
 118 void
 119 dnssd_xpc_message_set_parameters(xpc_object_t msg, xpc_object_t params)
 120 {
 121         xpc_dictionary_set_value(msg, DNSSD_XPC_MESSAGE_KEY_PARAMS, params);
 122 }
 123
 124 //======================================================================================================================
 125
 126 xpc_object_t
 127 dnssd_xpc_message_get_results(xpc_object_t msg)
 128 {
 129         return xpc_dictionary_get_array(msg, DNSSD_XPC_MESSAGE_KEY_RESULTS);
 130 }
 131
 132 //======================================================================================================================
 133
 134 void
 135 dnssd_xpc_message_set_results(xpc_object_t msg, xpc_object_t results)
 136 {
 137         xpc_dictionary_set_value(msg, DNSSD_XPC_MESSAGE_KEY_RESULTS, results);
 138 }
 139
 140 #if 0
 141 //======================================================================================================================
 142 #pragma mark - Parameter Dictionaries
 143 #endif
 144
 145 #define DNSSD_XPC_PARAMETERS_KEY_DELEGATE_ID            "delegate_id"
 146 #define DNSSD_XPC_PARAMETERS_KEY_FLAGS                          "flags"
 147 #define DNSSD_XPC_PARAMETERS_KEY_HOSTNAME                       "hostname"
 148 #define DNSSD_XPC_PARAMETERS_KEY_INTERFACE_INDEX        "interface_index"
 149 #define DNSSD_XPC_PARAMETERS_KEY_NEED_AUTH_TAGS         "need_auth_tags"
 150 #define DNSSD_XPC_PARAMETERS_KEY_PROTOCOLS                      "protocols"
 151
 152 //======================================================================================================================
 153
 154 pid_t
 155 dnssd_xpc_parameters_get_delegate_pid(xpc_object_t params, bool *out_valid)
 156 {
 157         return (pid_t)_dnssd_xpc_dictionary_get_int64(params, DNSSD_XPC_PARAMETERS_KEY_DELEGATE_ID, out_valid);
 158 }
 159
 160 //======================================================================================================================
 161
 162 void
 163 dnssd_xpc_parameters_set_delegate_pid(xpc_object_t params, pid_t pid)
 164 {
 165         xpc_dictionary_set_int64(params, DNSSD_XPC_PARAMETERS_KEY_DELEGATE_ID, pid);
 166 }
 167
 168 //======================================================================================================================
 169
 170 const uint8_t *
 171 dnssd_xpc_parameters_get_delegate_uuid(xpc_object_t params)
 172 {
 173         return xpc_dictionary_get_uuid(params, DNSSD_XPC_PARAMETERS_KEY_DELEGATE_ID);
 174 }
 175
 176 //======================================================================================================================
 177
 178 void
 179 dnssd_xpc_parameters_set_delegate_uuid(xpc_object_t params, uuid_t uuid)
 180 {
 181         xpc_dictionary_set_uuid(params, DNSSD_XPC_PARAMETERS_KEY_DELEGATE_ID, uuid);
 182 }
 183
 184 //======================================================================================================================
 185
 186 DNSServiceFlags
 187 dnssd_xpc_parameters_get_flags(xpc_object_t params, bool *out_valid)
 188 {
 189         return _dnssd_xpc_dictionary_get_uint32(params, DNSSD_XPC_PARAMETERS_KEY_FLAGS, out_valid);
 190 }
 191
 192 //======================================================================================================================
 193
 194 void
 195 dnssd_xpc_parameters_set_flags(xpc_object_t params, DNSServiceFlags flags)
 196 {
 197         xpc_dictionary_set_uint64(params, DNSSD_XPC_PARAMETERS_KEY_FLAGS, flags);
 198 }
 199
 200 //======================================================================================================================
 201
 202 xpc_object_t
 203 dnssd_xpc_parameters_get_hostname_object(xpc_object_t params)
 204 {
 205         return _dnssd_xpc_dictionary_get_value(params, DNSSD_XPC_PARAMETERS_KEY_HOSTNAME, XPC_TYPE_STRING);
 206 }
 207
 208 //======================================================================================================================
 209
 210 void
 211 dnssd_xpc_parameters_set_hostname(xpc_object_t params, const char *hostname)
 212 {
 213         xpc_dictionary_set_string(params, DNSSD_XPC_PARAMETERS_KEY_HOSTNAME, hostname);
 214 }
 215
 216 //======================================================================================================================
 217
 218 uint32_t
 219 dnssd_xpc_parameters_get_interface_index(xpc_object_t params, bool *out_valid)
 220 {
 221         return _dnssd_xpc_dictionary_get_uint32(params, DNSSD_XPC_PARAMETERS_KEY_INTERFACE_INDEX, out_valid);
 222 }
 223
 224 //======================================================================================================================
 225
 226 void
 227 dnssd_xpc_parameters_set_interface_index(xpc_object_t params, uint32_t interface_index)
 228 {
 229         xpc_dictionary_set_uint64(params, DNSSD_XPC_PARAMETERS_KEY_INTERFACE_INDEX, interface_index);
 230 }
 231
 232 //======================================================================================================================
 233
 234 bool
 235 dnssd_xpc_parameters_get_need_authentication_tags(xpc_object_t params)
 236 {
 237         return xpc_dictionary_get_bool(params, DNSSD_XPC_PARAMETERS_KEY_NEED_AUTH_TAGS);
 238 }
 239
 240 //======================================================================================================================
 241
 242 void
 243 dnssd_xpc_parameters_set_need_authentication_tags(xpc_object_t params, bool need_auth_tags)
 244 {
 245         xpc_dictionary_set_bool(params, DNSSD_XPC_PARAMETERS_KEY_NEED_AUTH_TAGS, need_auth_tags);
 246 }
 247
 248 //======================================================================================================================
 249
 250 DNSServiceProtocol
 251 dnssd_xpc_parameters_get_protocols(xpc_object_t params, bool *out_valid)
 252 {
 253         return _dnssd_xpc_dictionary_get_uint32(params, DNSSD_XPC_PARAMETERS_KEY_PROTOCOLS, out_valid);
 254 }
 255
 256 //======================================================================================================================
 257
 258 void
 259 dnssd_xpc_parameters_set_protocols(xpc_object_t params, DNSServiceProtocol protocols)
 260 {
 261         xpc_dictionary_set_uint64(params, DNSSD_XPC_PARAMETERS_KEY_PROTOCOLS, protocols);
 262 }
 263
 264 #if 0
 265 //======================================================================================================================
 266 #pragma mark - Result Dictionaries
 267 #endif
 268
 269 #define DNSSD_XPC_RESULT_KEY_AUTH_TAG                   "auth_tag"
 270 #define DNSSD_XPC_RESULT_KEY_ERROR                              "error"
 271 #define DNSSD_XPC_RESULT_KEY_FLAGS                              "flags"
 272 #define DNSSD_XPC_RESULT_KEY_INTERFACE_INDEX    "interface_index"
 273 #define DNSSD_XPC_RESULT_KEY_RECORD_CLASS               "rclass"
 274 #define DNSSD_XPC_RESULT_KEY_RECORD_DATA                "rdata"
 275 #define DNSSD_XPC_RESULT_KEY_RECORD_NAME                "rname"
 276 #define DNSSD_XPC_RESULT_KEY_RECORD_TYPE                "rtype"
 277
 278 //======================================================================================================================
 279
 280 xpc_object_t
 281 dnssd_xpc_result_get_authentication_tag_object(xpc_object_t result)
 282 {
 283         return _dnssd_xpc_dictionary_get_value(result, DNSSD_XPC_RESULT_KEY_AUTH_TAG, XPC_TYPE_DATA);
 284 }
 285
 286 //======================================================================================================================
 287
 288 void
 289 dnssd_xpc_result_set_authentication_tag(xpc_object_t result, const void *auth_tag_ptr, size_t auth_tag_len)
 290 {
 291         xpc_dictionary_set_data(result, DNSSD_XPC_RESULT_KEY_AUTH_TAG, auth_tag_ptr, auth_tag_len);
 292 }
 293
 294 //======================================================================================================================
 295
 296 DNSServiceErrorType
 297 dnssd_xpc_result_get_error(xpc_object_t result, bool *out_valid)
 298 {
 299         return _dnssd_xpc_dictionary_get_int32(result, DNSSD_XPC_RESULT_KEY_ERROR, out_valid);
 300 }
 301
 302 //======================================================================================================================
 303
 304 void
 305 dnssd_xpc_result_set_error(xpc_object_t result, DNSServiceErrorType error)
 306 {
 307         xpc_dictionary_set_int64(result, DNSSD_XPC_RESULT_KEY_ERROR, error);
 308 }
 309
 310 //======================================================================================================================
 311
 312 DNSServiceFlags
 313 dnssd_xpc_result_get_flags(xpc_object_t result, bool *out_valid)
 314 {
 315         return _dnssd_xpc_dictionary_get_uint32(result, DNSSD_XPC_RESULT_KEY_FLAGS, out_valid);
 316 }
 317
 318 //======================================================================================================================
 319
 320 void
 321 dnssd_xpc_result_set_flags(xpc_object_t result, DNSServiceFlags flags)
 322 {
 323         xpc_dictionary_set_uint64(result, DNSSD_XPC_RESULT_KEY_FLAGS, flags);
 324 }
 325
 326 //======================================================================================================================
 327
 328 uint32_t
 329 dnssd_xpc_result_get_interface_index(xpc_object_t result, bool *out_valid)
 330 {
 331         return _dnssd_xpc_dictionary_get_uint32(result, DNSSD_XPC_RESULT_KEY_INTERFACE_INDEX, out_valid);
 332 }
 333
 334 //======================================================================================================================
 335
 336 void
 337 dnssd_xpc_result_set_interface_index(xpc_object_t result, uint32_t interface_index)
 338 {
 339         xpc_dictionary_set_uint64(result, DNSSD_XPC_RESULT_KEY_INTERFACE_INDEX, interface_index);
 340 }
 341
 342 //======================================================================================================================
 343
 344 uint16_t
 345 dnssd_xpc_result_get_record_class(xpc_object_t result, bool *out_valid)
 346 {
 347         return _dnssd_xpc_dictionary_get_uint16(result, DNSSD_XPC_RESULT_KEY_RECORD_CLASS, out_valid);
 348 }
 349
 350 //======================================================================================================================
 351
 352 void
 353 dnssd_xpc_result_set_record_class(xpc_object_t result, uint16_t class)
 354 {
 355         xpc_dictionary_set_uint64(result, DNSSD_XPC_RESULT_KEY_RECORD_CLASS, class);
 356 }
 357
 358 //======================================================================================================================
 359
 360 xpc_object_t
 361 dnssd_xpc_result_get_record_data_object(xpc_object_t result)
 362 {
 363         return _dnssd_xpc_dictionary_get_value(result, DNSSD_XPC_RESULT_KEY_RECORD_DATA, XPC_TYPE_DATA);
 364 }
 365
 366 //======================================================================================================================
 367
 368 void
 369 dnssd_xpc_result_set_record_data(xpc_object_t result, const void *data_ptr, size_t data_len)
 370 {
 371         xpc_dictionary_set_data(result, DNSSD_XPC_RESULT_KEY_RECORD_DATA, data_ptr, data_len);
 372 }
 373
 374 //======================================================================================================================
 375
 376 xpc_object_t
 377 dnssd_xpc_result_get_record_name_object(xpc_object_t result)
 378 {
 379         return _dnssd_xpc_dictionary_get_value(result, DNSSD_XPC_RESULT_KEY_RECORD_NAME, XPC_TYPE_STRING);
 380 }
 381
 382 //======================================================================================================================
 383
 384 void
 385 dnssd_xpc_result_set_record_name(xpc_object_t result, const char *name)
 386 {
 387         xpc_dictionary_set_string(result, DNSSD_XPC_RESULT_KEY_RECORD_NAME, name);
 388 }
 389
 390 //======================================================================================================================
 391
 392 uint16_t
 393 dnssd_xpc_result_get_record_type(xpc_object_t result, bool *out_valid)
 394 {
 395         return _dnssd_xpc_dictionary_get_uint16(result, DNSSD_XPC_RESULT_KEY_RECORD_TYPE, out_valid);
 396 }
 397
 398 //======================================================================================================================
 399
 400 void
 401 dnssd_xpc_result_set_record_type(xpc_object_t result, uint16_t type)
 402 {
 403         xpc_dictionary_set_uint64(result, DNSSD_XPC_RESULT_KEY_RECORD_TYPE, type);
 404 }
 405
 406 #if 0
 407 //======================================================================================================================
 408 #pragma mark - XPC Dictionary Helpers
 409 #endif
 410
 411 static int32_t
 412 _dnssd_xpc_dictionary_get_int32(xpc_object_t dict, const char *key, bool *out_valid)
 413 {
 414         return (int32_t)_dnssd_xpc_dictionary_get_int64_limited(dict, key, INT32_MIN, INT32_MAX, out_valid);
 415 }
 416
 417 //======================================================================================================================
 418
 419 static int64_t
 420 _dnssd_xpc_dictionary_get_int64(xpc_object_t dict, const char *key, bool *out_valid)
 421 {
 422         return _dnssd_xpc_dictionary_get_int64_limited(dict, key, INT64_MIN, INT64_MAX, out_valid);
 423 }
 424
 425 //======================================================================================================================
 426
 427 static int64_t
 428 _dnssd_xpc_dictionary_get_int64_limited(xpc_object_t dict, const char *key, int64_t min, int64_t max, bool *out_valid)
 429 {
 430         int64_t i64;
 431         bool    valid;
 432
 433         xpc_object_t const value = _dnssd_xpc_dictionary_get_value(dict, key, XPC_TYPE_INT64);
 434         if (value) {
 435                 i64 = xpc_int64_get_value(value);
 436                 if ((i64 >= min) && (i64 <= max)) {
 437                         valid   = true;
 438                 } else {
 439                         i64             = 0;
 440                         valid   = false;
 441                 }
 442         } else {
 443                 i64             = 0;
 444                 valid   = false;
 445         }
 446         if (out_valid) {
 447                 *out_valid = valid;
 448         }
 449         return i64;
 450 }
 451
 452 //======================================================================================================================
 453
 454 static uint16_t
 455 _dnssd_xpc_dictionary_get_uint16(xpc_object_t dict, const char *key, bool *out_valid)
 456 {
 457         return (uint16_t)_dnssd_xpc_dictionary_get_uint64_limited(dict, key, 0, UINT16_MAX, out_valid);
 458 }
 459
 460 //======================================================================================================================
 461
 462 static uint32_t
 463 _dnssd_xpc_dictionary_get_uint32(xpc_object_t dict, const char *key, bool *out_valid)
 464 {
 465         return (uint32_t)_dnssd_xpc_dictionary_get_uint64_limited(dict, key, 0, UINT32_MAX, out_valid);
 466 }
 467
 468 //======================================================================================================================
 469
 470 static uint64_t
 471 _dnssd_xpc_dictionary_get_uint64(xpc_object_t dict, const char *key, bool *out_valid)
 472 {
 473         return _dnssd_xpc_dictionary_get_uint64_limited(dict, key, 0, UINT64_MAX, out_valid);
 474 }
 475
 476 //======================================================================================================================
 477
 478 static uint64_t
 479 _dnssd_xpc_dictionary_get_uint64_limited(xpc_object_t dict, const char *key, uint64_t min, uint64_t max,
 480         bool *out_valid)
 481 {
 482         uint64_t        u64;
 483         bool            valid;
 484
 485         xpc_object_t const value = _dnssd_xpc_dictionary_get_value(dict, key, XPC_TYPE_UINT64);
 486         if (value) {
 487                 u64 = xpc_uint64_get_value(value);
 488                 if ((u64 >= min) && (u64 <= max)) {
 489                         valid   = true;
 490                 } else {
 491                         u64             = 0;
 492                         valid   = false;
 493                 }
 494         } else {
 495                 u64             = 0;
 496                 valid   = false;
 497         }
 498         if (out_valid) {
 499                 *out_valid = valid;
 500         }
 501         return u64;
 502 }
 503
 504 //======================================================================================================================
 505
 506 static xpc_object_t
 507 _dnssd_xpc_dictionary_get_value(xpc_object_t dict, const char *key, xpc_type_t type)
 508 {
 509         xpc_object_t value = xpc_dictionary_get_value(dict, key);
 510         return (value && (xpc_get_type(value) == type)) ? value : NULL;
 511 }