libkern/OSKextVersion.c

   1 /*
   2  * Copyright (c) 2000-2016 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 #ifdef KERNEL
  29 #include <sys/systm.h>
  30 #include <libkern/OSKextLib.h>
  31 #include <libkern/OSKextLibPrivate.h>
  32 #else
  33 #include <libc.h>
  34 #include <libkern/OSKextLib.h>
  35 #include <System/libkern/OSKextLibPrivate.h>
  36 #endif /* KERNEL */
  37
  38 #include <libkern/OSKextLibPrivate.h>
  39
  40 #define VERS_MAJOR_DIGITS        (4)
  41 #define VERS_MINOR_DIGITS        (4)
  42 #define VERS_REVISION_DIGITS     (4)
  43 #define VERS_STAGE_DIGITS        (1)
  44 #define VERS_STAGE_LEVEL_DIGITS  (3)
  45
  46 #define VERS_MAJOR_MAX           (9999)
  47 #define VERS_STAGE_LEVEL_MAX      (255)
  48
  49 #define VERS_MAJOR_MULT  (1000000000000)
  50 #define VERS_MINOR_MULT      (100000000)
  51 #define VERS_REVISION_MULT       (10000)
  52 #define VERS_STAGE_MULT           (1000)
  53
  54
  55 typedef enum {
  56     kOSKextVersionStageInvalid     = 0,
  57     kOSKextVersionStageDevelopment = 1,
  58     kOSKextVersionStageAlpha       = 3,
  59     kOSKextVersionStageBeta        = 5,
  60     kOSKextVersionStageCandidate   = 7,
  61     kOSKextVersionStageRelease     = 9,
  62 } OSKextVersionStage;
  63
  64
  65 /*********************************************************************
  66 *********************************************************************/
  67 static int __vers_isdigit(char c) {
  68     return (c == '0' ||
  69         c == '1' || c == '2' || c == '3' ||
  70         c == '4' || c == '5' || c == '6' ||
  71         c == '7' || c == '8' || c == '9');
  72 }
  73
  74 /*********************************************************************
  75 *********************************************************************/
  76 static int __vers_isspace(char c) {
  77     return (c == ' ' ||
  78         c == '\t' ||
  79         c == '\r' ||
  80         c == '\n');
  81 }
  82
  83 /*********************************************************************
  84 *********************************************************************/
  85 static int
  86 __vers_digit_for_char(char c) {
  87         switch (c) {
  88                 case '0': return 0;
  89                 case '1': return 1;
  90                 case '2': return 2;
  91                 case '3': return 3;
  92                 case '4': return 4;
  93                 case '5': return 5;
  94                 case '6': return 6;
  95                 case '7': return 7;
  96                 case '8': return 8;
  97                 case '9': return 9;
  98                 default:  return -1;
  99         }
 100 }
 101
 102 /*********************************************************************
 103 *********************************************************************/
 104 static int __VERS_isreleasestate(char c) {
 105     return (c == 'd' || c == 'a' || c == 'b' || c == 'f');
 106 }
 107
 108
 109 /*********************************************************************
 110 *********************************************************************/
 111 static OSKextVersionStage __OSKextVersionStageForString(const char ** string_p) {
 112     const char * string;
 113
 114     if (!string_p || !*string_p) {
 115         return kOSKextVersionStageInvalid;
 116     }
 117
 118     string = *string_p;
 119
 120     if (__vers_isspace(string[0]) || string[0] == '\0') {
 121         return kOSKextVersionStageRelease;
 122     } else {
 123         switch (string[0]) {
 124           case 'd':
 125               if (__vers_isdigit(string[1])) {
 126                   *string_p = &string[1];
 127                   return kOSKextVersionStageDevelopment;
 128               }
 129               break;
 130           case 'a':
 131               if (__vers_isdigit(string[1])) {
 132                   *string_p = &string[1];
 133                   return kOSKextVersionStageAlpha;
 134               }
 135               break;
 136           case 'b':
 137               if (__vers_isdigit(string[1])) {
 138                   *string_p = &string[1];
 139                   return kOSKextVersionStageBeta;
 140               }
 141               break;
 142           case 'f':
 143               if (__vers_isdigit(string[1])) {
 144                   *string_p = &string[1];
 145                   return kOSKextVersionStageCandidate;
 146               } else if (string[1] == 'c' && __vers_isdigit(string[2])) {
 147                   *string_p = &string[2];
 148                   return kOSKextVersionStageCandidate;
 149               } else {
 150                   return kOSKextVersionStageInvalid;
 151               }
 152           default:
 153               return kOSKextVersionStageInvalid;
 154         }
 155     }
 156
 157     return kOSKextVersionStageInvalid;
 158 }
 159
 160 /*********************************************************************
 161 *********************************************************************/
 162 static const char *
 163 __OSKextVersionStringForStage(OSKextVersionStage stage)
 164 {
 165         switch (stage) {
 166                 case kOSKextVersionStageInvalid:     return NULL;
 167                 case kOSKextVersionStageDevelopment: return "d";
 168                 case kOSKextVersionStageAlpha:       return "a";
 169                 case kOSKextVersionStageBeta:        return "b";
 170                 case kOSKextVersionStageCandidate:   return "f";
 171                 case kOSKextVersionStageRelease:     return "";
 172         }
 173 }
 174
 175 /*********************************************************************
 176 *********************************************************************/
 177 OSKextVersion OSKextParseVersionString(const char * versionString)
 178 {
 179     OSKextVersion   result             = -1;
 180     int             vers_digit         = -1;
 181     int             num_digits_scanned = 0;
 182     OSKextVersion   vers_major         = 0;
 183     OSKextVersion   vers_minor         = 0;
 184     OSKextVersion   vers_revision      = 0;
 185     OSKextVersion   vers_stage         = 0;
 186     OSKextVersion   vers_stage_level   = 0;
 187     const char    * current_char_p;
 188
 189     if (!versionString || *versionString == '\0') {
 190         return -1;
 191     }
 192
 193     current_char_p = (const char *)&versionString[0];
 194
 195    /*****
 196     * Check for an initial digit of the major release number.
 197     */
 198     vers_major = __vers_digit_for_char(*current_char_p);
 199     if (vers_major < 0) {
 200         return -1;
 201     }
 202
 203     current_char_p++;
 204     num_digits_scanned = 1;
 205
 206    /* Complete scan for major version number. Legal characters are
 207     * any digit, period, any buildstage letter.
 208     */
 209     while (num_digits_scanned < VERS_MAJOR_DIGITS) {
 210         if (__vers_isspace(*current_char_p) || *current_char_p == '\0') {
 211             vers_stage = kOSKextVersionStageRelease;
 212             goto finish;
 213         } else if (__vers_isdigit(*current_char_p)) {
 214             vers_digit = __vers_digit_for_char(*current_char_p);
 215             if (vers_digit < 0) {
 216                 return -1;
 217             }
 218             vers_major = (vers_major) * 10 + vers_digit;
 219             current_char_p++;
 220             num_digits_scanned++;
 221         } else if (__VERS_isreleasestate(*current_char_p)) {
 222             goto release_state;
 223         } else if (*current_char_p == '.') {
 224             current_char_p++;
 225             goto minor_version;
 226         } else {
 227             return -1;
 228         }
 229     }
 230
 231    /* Check for too many digits.
 232     */
 233     if (num_digits_scanned == VERS_MAJOR_DIGITS) {
 234          if (*current_char_p == '.') {
 235             current_char_p++;
 236         } else if (__vers_isdigit(*current_char_p)) {
 237             return -1;
 238         }
 239     }
 240
 241 minor_version:
 242
 243     num_digits_scanned = 0;
 244
 245    /* Scan for minor version number. Legal characters are
 246     * any digit, period, any buildstage letter.
 247     */
 248     while (num_digits_scanned < VERS_MINOR_DIGITS) {
 249         if (__vers_isspace(*current_char_p) || *current_char_p == '\0') {
 250             vers_stage = kOSKextVersionStageRelease;
 251             goto finish;
 252         } else if (__vers_isdigit(*current_char_p)) {
 253             vers_digit = __vers_digit_for_char(*current_char_p);
 254             if (vers_digit < 0) {
 255                 return -1;
 256             }
 257             vers_minor = (vers_minor) * 10 + vers_digit;
 258             current_char_p++;
 259             num_digits_scanned++;
 260         } else if (__VERS_isreleasestate(*current_char_p)) {
 261             goto release_state;
 262         } else if (*current_char_p == '.') {
 263             current_char_p++;
 264             goto revision;
 265         } else {
 266             return -1;
 267         }
 268     }
 269
 270    /* Check for too many digits.
 271     */
 272     if (num_digits_scanned == VERS_MINOR_DIGITS) {
 273          if (*current_char_p == '.') {
 274             current_char_p++;
 275         } else if (__vers_isdigit(*current_char_p)) {
 276             return -1;
 277         }
 278     }
 279
 280 revision:
 281
 282     num_digits_scanned = 0;
 283
 284    /* Scan for revision version number. Legal characters are
 285     * any digit, any buildstage letter (NOT PERIOD).
 286     */
 287     while (num_digits_scanned < VERS_REVISION_DIGITS) {
 288         if (__vers_isspace(*current_char_p) || *current_char_p == '\0') {
 289             vers_stage = kOSKextVersionStageRelease;
 290             goto finish;
 291         } else if (__vers_isdigit(*current_char_p)) {
 292             vers_digit = __vers_digit_for_char(*current_char_p);
 293             if (vers_digit < 0) {
 294                 return -1;
 295             }
 296             vers_revision = (vers_revision) * 10 + vers_digit;
 297             current_char_p++;
 298             num_digits_scanned++;
 299         } else if (__VERS_isreleasestate(*current_char_p)) {
 300             goto release_state;
 301         } else {
 302             return -1;
 303         }
 304     }
 305
 306    /* Check for too many digits.
 307     */
 308     if (num_digits_scanned == VERS_REVISION_DIGITS) {
 309          if (*current_char_p == '.') {
 310             current_char_p++;
 311         } else if (__vers_isdigit(*current_char_p)) {
 312             return -1;
 313         }
 314     }
 315
 316 release_state:
 317
 318    /*****
 319     * Check for the release state.
 320     */
 321     if (__vers_isspace(*current_char_p) || *current_char_p == '\0') {
 322         vers_stage = kOSKextVersionStageRelease;
 323         goto finish;
 324     } else {
 325         vers_stage = __OSKextVersionStageForString(&current_char_p);
 326         if (vers_stage == kOSKextVersionStageInvalid) {
 327             return -1;
 328         }
 329     }
 330
 331
 332 // stage level
 333
 334     num_digits_scanned = 0;
 335
 336    /* Scan for stage level number. Legal characters are
 337     * any digit only.
 338     */
 339     while (num_digits_scanned < VERS_STAGE_LEVEL_DIGITS) {
 340         if (__vers_isspace(*current_char_p) || *current_char_p == '\0') {
 341             if (num_digits_scanned) {
 342                 goto finish;
 343             } else {
 344                 return -1;
 345             }
 346         } else if (__vers_isdigit(*current_char_p)) {
 347             vers_digit = __vers_digit_for_char(*current_char_p);
 348             if (vers_digit < 0) {
 349                 return -1;
 350             }
 351             vers_stage_level = (vers_stage_level) * 10 + vers_digit;
 352             current_char_p++;
 353             num_digits_scanned++;
 354         } else {
 355             return -1;
 356         }
 357     }
 358
 359    /* Check for too many digits.
 360     */
 361     if ((num_digits_scanned == VERS_STAGE_LEVEL_DIGITS) &&
 362         ! (__vers_isspace(*current_char_p) || (*current_char_p == '\0'))) {
 363
 364         return -1;
 365     }
 366
 367     if (vers_stage_level > VERS_STAGE_LEVEL_MAX) {
 368         return -1;
 369     }
 370
 371 finish:
 372
 373     if (vers_stage == kOSKextVersionStageCandidate && vers_stage_level == 0) {
 374         return -1;
 375     }
 376
 377     result = (vers_major * VERS_MAJOR_MULT) +
 378              (vers_minor * VERS_MINOR_MULT) +
 379              (vers_revision * VERS_REVISION_MULT) +
 380              (vers_stage * VERS_STAGE_MULT) +
 381              vers_stage_level;
 382
 383     return result;
 384 }
 385
 386 /*********************************************************************
 387 * This function must be safe to call in panic context.
 388 *********************************************************************/
 389 Boolean OSKextVersionGetString(
 390     OSKextVersion   aVersion,
 391     char          * buffer,
 392     uint32_t        bufferLength)
 393 {
 394     int             cpos = 0;
 395     OSKextVersion   vers_major = 0;
 396     OSKextVersion   vers_minor = 0;
 397     OSKextVersion   vers_revision = 0;
 398     OSKextVersion   vers_stage = 0;
 399     OSKextVersion   vers_stage_level = 0;
 400     const char    * stage_string = NULL;  // don't free
 401
 402    /* No buffer or length less than longest possible vers string,
 403     * return 0.
 404     */
 405     if (!buffer || bufferLength < kOSKextVersionMaxLength) {
 406         return FALSE;
 407     }
 408
 409     bzero(buffer, bufferLength * sizeof(char));
 410
 411     if (aVersion < 0) {
 412         strlcpy(buffer, "(invalid)", bufferLength);
 413         return TRUE;
 414     }
 415     if (aVersion == 0) {
 416         strlcpy(buffer, "(missing)", bufferLength);
 417         return TRUE;
 418     }
 419
 420     vers_major = aVersion / VERS_MAJOR_MULT;
 421     if (vers_major > VERS_MAJOR_MAX) {
 422         strlcpy(buffer, "(invalid)", bufferLength);
 423         return TRUE;
 424     }
 425
 426     vers_minor = aVersion - (vers_major * VERS_MAJOR_MULT);
 427     vers_minor /= VERS_MINOR_MULT;
 428
 429     vers_revision = aVersion -
 430         ( (vers_major * VERS_MAJOR_MULT) + (vers_minor * VERS_MINOR_MULT) );
 431     vers_revision /= VERS_REVISION_MULT;
 432
 433     vers_stage = aVersion -
 434         ( (vers_major * VERS_MAJOR_MULT) + (vers_minor * VERS_MINOR_MULT) +
 435           (vers_revision * VERS_REVISION_MULT));
 436     vers_stage /= VERS_STAGE_MULT;
 437
 438     vers_stage_level = aVersion -
 439         ( (vers_major * VERS_MAJOR_MULT) + (vers_minor * VERS_MINOR_MULT) +
 440           (vers_revision * VERS_REVISION_MULT) + (vers_stage * VERS_STAGE_MULT));
 441     if (vers_stage_level > VERS_STAGE_LEVEL_MAX) {
 442         strlcpy(buffer, "(invalid)", bufferLength);
 443         return TRUE;
 444     }
 445
 446     cpos = snprintf(buffer, bufferLength, "%u", (uint32_t)vers_major);
 447
 448    /* Always include the minor version; it just looks weird without.
 449     */
 450     buffer[cpos] = '.';
 451     cpos++;
 452     cpos += snprintf(buffer+cpos, bufferLength - cpos, "%u", (uint32_t)vers_minor);
 453
 454    /* The revision is displayed only if nonzero.
 455     */
 456     if (vers_revision) {
 457         buffer[cpos] = '.';
 458         cpos++;
 459         cpos += snprintf(buffer+cpos, bufferLength - cpos, "%u",
 460                         (uint32_t)vers_revision);
 461     }
 462
 463     stage_string = __OSKextVersionStringForStage(vers_stage);
 464     if (!stage_string) {
 465         strlcpy(buffer, "(invalid)", bufferLength);
 466         return TRUE;
 467     }
 468     if (stage_string[0]) {
 469         strlcat(buffer, stage_string, bufferLength);
 470         cpos += strlen(stage_string);
 471     }
 472
 473     if (vers_stage < kOSKextVersionStageRelease) {
 474         snprintf(buffer+cpos, bufferLength - cpos, "%u", (uint32_t)vers_stage_level);
 475     }
 476
 477     return TRUE;
 478 }
 479
 480 /*********************************************************************
 481 *********************************************************************/
 482 #ifndef KERNEL
 483 OSKextVersion OSKextParseVersionCFString(CFStringRef versionString)
 484 {
 485     OSKextVersion result = -1;
 486     char         versBuffer[kOSKextVersionMaxLength];
 487
 488     if (CFStringGetCString(versionString, versBuffer,
 489         sizeof(versBuffer), kCFStringEncodingASCII)) {
 490
 491         result = OSKextParseVersionString(versBuffer);
 492     }
 493     return result;
 494 }
 495 #endif