![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stcnfg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / network / tdi|
Return to stcnfg.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / network / tdi |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1989-1993 Microsoft Corporation ! 4: ! 5: Module Name: ! 6: ! 7: stcnfg.c ! 8: ! 9: Abstract: ! 10: ! 11: This contains all routines necessary for the support of the dynamic ! 12: configuration of ST. ! 13: ! 14: Revision History: ! 15: ! 16: --*/ ! 17: ! 18: #include "st.h" ! 19: ! 20: ! 21: // ! 22: // Local functions used to access the registry. ! 23: // ! 24: ! 25: NTSTATUS ! 26: StConfigureTransport ( ! 27: IN PUNICODE_STRING RegistryPath, ! 28: IN PCONFIG_DATA * ConfigurationInfoPtr ! 29: ); ! 30: ! 31: VOID ! 32: StFreeConfigurationInfo ( ! 33: IN PCONFIG_DATA ConfigurationInfo ! 34: ); ! 35: ! 36: NTSTATUS ! 37: StOpenParametersKey( ! 38: IN HANDLE StConfigHandle, ! 39: OUT PHANDLE ParametersHandle ! 40: ); ! 41: ! 42: VOID ! 43: StCloseParametersKey( ! 44: IN HANDLE ParametersHandle ! 45: ); ! 46: ! 47: NTSTATUS ! 48: StCountEntries( ! 49: IN PWSTR ValueName, ! 50: IN ULONG ValueType, ! 51: IN PVOID ValueData, ! 52: IN ULONG ValueLength, ! 53: IN PVOID Context, ! 54: IN PVOID EntryContext ! 55: ); ! 56: ! 57: NTSTATUS ! 58: StAddBind( ! 59: IN PWSTR ValueName, ! 60: IN ULONG ValueType, ! 61: IN PVOID ValueData, ! 62: IN ULONG ValueLength, ! 63: IN PVOID Context, ! 64: IN PVOID EntryContext ! 65: ); ! 66: ! 67: NTSTATUS ! 68: StAddExport( ! 69: IN PWSTR ValueName, ! 70: IN ULONG ValueType, ! 71: IN PVOID ValueData, ! 72: IN ULONG ValueLength, ! 73: IN PVOID Context, ! 74: IN PVOID EntryContext ! 75: ); ! 76: ! 77: VOID ! 78: StReadLinkageInformation( ! 79: IN PWSTR RegistryPathBuffer, ! 80: IN PCONFIG_DATA * ConfigurationInfo ! 81: ); ! 82: ! 83: UINT ! 84: StReadSizeInformation( ! 85: IN HANDLE ParametersHandle ! 86: ); ! 87: ! 88: ULONG ! 89: StReadSingleParameter( ! 90: IN HANDLE ParametersHandle, ! 91: IN PWCHAR ValueName, ! 92: IN ULONG DefaultValue ! 93: ); ! 94: ! 95: VOID ! 96: StWriteSingleParameter( ! 97: IN HANDLE ParametersHandle, ! 98: IN PWCHAR ValueName, ! 99: IN ULONG ValueData ! 100: ); ! 101: ! 102: VOID ! 103: StSaveConfigInRegistry( ! 104: IN HANDLE ParametersHandle, ! 105: IN PCONFIG_DATA ConfigurationInfo ! 106: ); ! 107: ! 108: UINT ! 109: StWstrLength( ! 110: IN PWSTR Wstr ! 111: ); ! 112: ! 113: #ifdef ALLOC_PRAGMA ! 114: #pragma alloc_text(init,StWstrLength) ! 115: #pragma alloc_text(init,StConfigureTransport) ! 116: #pragma alloc_text(init,StFreeConfigurationInfo) ! 117: #pragma alloc_text(init,StOpenParametersKey) ! 118: #pragma alloc_text(init,StCloseParametersKey) ! 119: #pragma alloc_text(init,StCountEntries) ! 120: #pragma alloc_text(init,StAddBind) ! 121: #pragma alloc_text(init,StAddExport) ! 122: #pragma alloc_text(init,StReadLinkageInformation) ! 123: #pragma alloc_text(init,StReadSingleParameter) ! 124: #pragma alloc_text(init,StWriteSingleParameter) ! 125: #pragma alloc_text(init,StSaveConfigInRegistry) ! 126: #endif ! 127: ! 128: ! 129: UINT ! 130: StWstrLength( ! 131: IN PWSTR Wstr ! 132: ) ! 133: { ! 134: UINT Length = 0; ! 135: while (*Wstr++) { ! 136: Length += sizeof(WCHAR); ! 137: } ! 138: return Length; ! 139: } ! 140: ! 141: #define InsertAdapter(ConfigurationInfo, Subscript, Name) \ ! 142: { \ ! 143: PWSTR _S; \ ! 144: PWSTR _N = (Name); \ ! 145: UINT _L = StWstrLength(_N)+sizeof(WCHAR); \ ! 146: _S = (PWSTR)ExAllocatePool(NonPagedPool, _L); \ ! 147: if (_S != NULL) { \ ! 148: RtlCopyMemory(_S, _N, _L); \ ! 149: RtlInitUnicodeString (&(ConfigurationInfo)->Names[Subscript], _S); \ ! 150: } \ ! 151: } ! 152: ! 153: #define InsertDevice(ConfigurationInfo, Subscript, Name) \ ! 154: { \ ! 155: PWSTR _S; \ ! 156: PWSTR _N = (Name); \ ! 157: UINT _L = StWstrLength(_N)+sizeof(WCHAR); \ ! 158: _S = (PWSTR)ExAllocatePool(NonPagedPool, _L); \ ! 159: if (_S != NULL) { \ ! 160: RtlCopyMemory(_S, _N, _L); \ ! 161: RtlInitUnicodeString (&(ConfigurationInfo)->Names[(ConfigurationInfo)->DevicesOffset+Subscript], _S); \ ! 162: } \ ! 163: } ! 164: ! 165: ! 166: #define RemoveAdapter(ConfigurationInfo, Subscript) \ ! 167: ExFreePool ((ConfigurationInfo)->Names[Subscript].Buffer) ! 168: ! 169: #define RemoveDevice(ConfigurationInfo, Subscript) \ ! 170: ExFreePool ((ConfigurationInfo)->Names[(ConfigurationInfo)->DevicesOffset+Subscript].Buffer) ! 171: ! 172: ! 173: ! 174: // ! 175: // These strings are used in various places by the registry. ! 176: // ! 177: ! 178: #define DECLARE_STRING(_str_) STATIC WCHAR Str ## _str_[] = L#_str_ ! 179: ! 180: DECLARE_STRING(Large); ! 181: DECLARE_STRING(Medium); ! 182: DECLARE_STRING(Small); ! 183: ! 184: DECLARE_STRING(InitRequests); ! 185: DECLARE_STRING(InitConnections); ! 186: DECLARE_STRING(InitAddressFiles); ! 187: DECLARE_STRING(InitAddresses); ! 188: ! 189: DECLARE_STRING(MaxRequests); ! 190: DECLARE_STRING(MaxConnections); ! 191: DECLARE_STRING(MaxAddressFiles); ! 192: DECLARE_STRING(MaxAddresses); ! 193: ! 194: DECLARE_STRING(InitPackets); ! 195: DECLARE_STRING(InitReceivePackets); ! 196: DECLARE_STRING(InitReceiveBuffers); ! 197: ! 198: DECLARE_STRING(SendPacketPoolSize); ! 199: DECLARE_STRING(ReceivePacketPoolSize); ! 200: DECLARE_STRING(MaxMemoryUsage); ! 201: ! 202: ! 203: #define READ_HIDDEN_CONFIG(_Field) \ ! 204: { \ ! 205: ConfigurationInfo->_Field = \ ! 206: StReadSingleParameter( \ ! 207: ParametersHandle, \ ! 208: Str ## _Field, \ ! 209: ConfigurationInfo->_Field); \ ! 210: } ! 211: ! 212: #define WRITE_HIDDEN_CONFIG(_Field) \ ! 213: { \ ! 214: StWriteSingleParameter( \ ! 215: ParametersHandle, \ ! 216: Str ## _Field, \ ! 217: ConfigurationInfo->_Field); \ ! 218: } ! 219: ! 220: ! 221: ! 222: NTSTATUS ! 223: StConfigureTransport ( ! 224: IN PUNICODE_STRING RegistryPath, ! 225: IN PCONFIG_DATA * ConfigurationInfoPtr ! 226: ) ! 227: /*++ ! 228: ! 229: Routine Description: ! 230: ! 231: This routine is called by ST to get information from the configuration ! 232: management routines. We read the registry, starting at RegistryPath, ! 233: to get the parameters. If they don't exist, we use the defaults ! 234: set in nbfcnfg.h file. ! 235: ! 236: Arguments: ! 237: ! 238: RegistryPath - The name of ST's node in the registry. ! 239: ! 240: ConfigurationInfoPtr - A pointer to the configuration information structure. ! 241: ! 242: Return Value: ! 243: ! 244: Status - STATUS_SUCCESS if everything OK, STATUS_INSUFFICIENT_RESOURCES ! 245: otherwise. ! 246: ! 247: --*/ ! 248: { ! 249: ! 250: NTSTATUS OpenStatus; ! 251: HANDLE ParametersHandle; ! 252: UINT StSize; ! 253: HANDLE StConfigHandle; ! 254: NTSTATUS Status; ! 255: ULONG Disposition; ! 256: PWSTR RegistryPathBuffer; ! 257: OBJECT_ATTRIBUTES TmpObjectAttributes; ! 258: PCONFIG_DATA ConfigurationInfo; ! 259: ! 260: ! 261: // ! 262: // Open the registry. ! 263: // ! 264: ! 265: InitializeObjectAttributes( ! 266: &TmpObjectAttributes, ! 267: RegistryPath, // name ! 268: OBJ_CASE_INSENSITIVE, // attributes ! 269: NULL, // root ! 270: NULL // security descriptor ! 271: ); ! 272: ! 273: Status = ZwCreateKey( ! 274: &StConfigHandle, ! 275: KEY_WRITE, ! 276: &TmpObjectAttributes, ! 277: 0, // title index ! 278: NULL, // class ! 279: 0, // create options ! 280: &Disposition); // disposition ! 281: ! 282: if (!NT_SUCCESS(Status)) { ! 283: StPrint1("ST: Could not open/create ST key: %lx\n", Status); ! 284: return Status; ! 285: } ! 286: ! 287: ! 288: OpenStatus = StOpenParametersKey (StConfigHandle, &ParametersHandle); ! 289: ! 290: if (OpenStatus != STATUS_SUCCESS) { ! 291: return OpenStatus; ! 292: } ! 293: ! 294: // ! 295: // Read in the NDIS binding information (if none is present ! 296: // the array will be filled with all known drivers). ! 297: // ! 298: // StReadLinkageInformation expects a null-terminated path, ! 299: // so we have to create one from the UNICODE_STRING. ! 300: // ! 301: ! 302: RegistryPathBuffer = (PWSTR)ExAllocatePool( ! 303: NonPagedPool, ! 304: RegistryPath->Length + sizeof(WCHAR)); ! 305: if (RegistryPathBuffer == NULL) { ! 306: StCloseParametersKey (ParametersHandle); ! 307: return STATUS_INSUFFICIENT_RESOURCES; ! 308: } ! 309: RtlCopyMemory (RegistryPathBuffer, RegistryPath->Buffer, RegistryPath->Length); ! 310: *(PWCHAR)(((PUCHAR)RegistryPathBuffer)+RegistryPath->Length) = (WCHAR)'\0'; ! 311: ! 312: StReadLinkageInformation (RegistryPathBuffer, ConfigurationInfoPtr); ! 313: ! 314: if (*ConfigurationInfoPtr == NULL) { ! 315: ExFreePool (RegistryPathBuffer); ! 316: StCloseParametersKey (ParametersHandle); ! 317: return STATUS_INSUFFICIENT_RESOURCES; ! 318: } ! 319: ConfigurationInfo = *ConfigurationInfoPtr; ! 320: ! 321: ! 322: // ! 323: // Read the size parameter; this returns 0 if none is ! 324: // present, or 1 (Small), 2 (Medium) and 3 (Large). ! 325: // ! 326: ! 327: StSize = StReadSizeInformation (ParametersHandle); ! 328: ! 329: switch (StSize) { ! 330: ! 331: case 0: ! 332: case 1: ! 333: ! 334: // ! 335: // Default is Small. ! 336: // ! 337: ! 338: // ! 339: // These are the initial value used; the comment after ! 340: // each one shows the expected maximum (if every resource ! 341: // is at the expected maximum, ST should be very close ! 342: // to being out of memory). ! 343: // ! 344: // For now the "Max" values default to 0 (no limit). ! 345: // ! 346: ! 347: ConfigurationInfo->InitRequests = 5; // 30 ! 348: ConfigurationInfo->InitConnections = 1; // 10 ! 349: ConfigurationInfo->InitAddressFiles = 0; // 10 ! 350: ConfigurationInfo->InitAddresses = 0; // 10 ! 351: ! 352: // ! 353: // These are the initial values; remember that the ! 354: // resources above also allocate some of these each ! 355: // time they are allocated (shown in the comment). ! 356: // ! 357: ! 358: ConfigurationInfo->InitPackets = 30; // + link + conn (40) ! 359: ConfigurationInfo->InitReceivePackets = 10; // + link + addr (30) ! 360: ConfigurationInfo->InitReceiveBuffers = 5; // + addr (15) ! 361: ! 362: // ! 363: // Set the size of the packet pools and the total ! 364: // allocateable by ST. ! 365: // ! 366: ! 367: ConfigurationInfo->SendPacketPoolSize = 100; ! 368: ConfigurationInfo->ReceivePacketPoolSize = 30; ! 369: ConfigurationInfo->MaxMemoryUsage = 100000; ! 370: ! 371: break; ! 372: ! 373: case 2: ! 374: ! 375: // ! 376: // Medium ST. ! 377: // ! 378: ! 379: // ! 380: // These are the initial value used; the comment after ! 381: // each one shows the expected maximum (if every resource ! 382: // is at the expected maximum, ST should be very close ! 383: // to being out of memory). ! 384: // ! 385: // For now the "Max" values default to 0 (no limit). ! 386: // ! 387: ! 388: ConfigurationInfo->InitRequests = 10; // 100 ! 389: ConfigurationInfo->InitConnections = 2; // 64 ! 390: ConfigurationInfo->InitAddressFiles = 1; // 20 ! 391: ConfigurationInfo->InitAddresses = 1; // 20 ! 392: ! 393: // ! 394: // These are the initial values; remember that the ! 395: // resources above also allocate some of these each ! 396: // time they are allocated (shown in the comment). ! 397: // ! 398: ! 399: ConfigurationInfo->InitPackets = 50; // + link + conn (150) ! 400: ConfigurationInfo->InitReceivePackets = 15; // + link + addr (100) ! 401: ConfigurationInfo->InitReceiveBuffers = 10; // + addr (30) ! 402: ! 403: // ! 404: // Set the size of the packet pools and the total ! 405: // allocateable by ST. ! 406: // ! 407: ! 408: ConfigurationInfo->SendPacketPoolSize = 250; ! 409: ConfigurationInfo->ReceivePacketPoolSize = 100; ! 410: ConfigurationInfo->MaxMemoryUsage = 250000; ! 411: ! 412: break; ! 413: ! 414: case 3: ! 415: ! 416: // ! 417: // Big ST. ! 418: // ! 419: ! 420: // ! 421: // These are the initial value used. ! 422: // ! 423: // For now the "Max" values default to 0 (no limit). ! 424: // ! 425: ! 426: ConfigurationInfo->InitRequests = 15; ! 427: ConfigurationInfo->InitConnections = 3; ! 428: ConfigurationInfo->InitAddressFiles = 2; ! 429: ConfigurationInfo->InitAddresses = 2; ! 430: ! 431: // ! 432: // These are the initial values; remember that the ! 433: // resources above also allocate some of these each ! 434: // time they are allocated (shown in the comment). ! 435: // ! 436: ! 437: ConfigurationInfo->InitPackets = 75; // + link + conn ! 438: ConfigurationInfo->InitReceivePackets = 25; // + link + addr ! 439: ConfigurationInfo->InitReceiveBuffers = 20; // + addr ! 440: ! 441: // ! 442: // Set the size of the packet pools and the total ! 443: // allocateable by ST. ! 444: // ! 445: ! 446: ConfigurationInfo->SendPacketPoolSize = 500; ! 447: ConfigurationInfo->ReceivePacketPoolSize = 200; ! 448: ConfigurationInfo->MaxMemoryUsage = 0; // no limit ! 449: ! 450: break; ! 451: ! 452: default: ! 453: ! 454: ASSERT(FALSE); ! 455: break; ! 456: ! 457: } ! 458: ! 459: ! 460: // ! 461: // Now read the optional "hidden" parameters; if these do ! 462: // not exist then the current values are used. Note that ! 463: // the current values will be 0 unless they have been ! 464: // explicitly initialized above. ! 465: // ! 466: // NOTE: These macros expect "ConfigurationInfo" and ! 467: // "ParametersHandle" to exist when they are expanded. ! 468: // ! 469: ! 470: READ_HIDDEN_CONFIG (InitRequests); ! 471: READ_HIDDEN_CONFIG (InitConnections); ! 472: READ_HIDDEN_CONFIG (InitAddressFiles); ! 473: READ_HIDDEN_CONFIG (InitAddresses); ! 474: ! 475: READ_HIDDEN_CONFIG (MaxRequests); ! 476: READ_HIDDEN_CONFIG (MaxConnections); ! 477: READ_HIDDEN_CONFIG (MaxAddressFiles); ! 478: READ_HIDDEN_CONFIG (MaxAddresses); ! 479: ! 480: READ_HIDDEN_CONFIG (InitPackets); ! 481: READ_HIDDEN_CONFIG (InitReceivePackets); ! 482: READ_HIDDEN_CONFIG (InitReceiveBuffers); ! 483: ! 484: READ_HIDDEN_CONFIG (SendPacketPoolSize); ! 485: READ_HIDDEN_CONFIG (ReceivePacketPoolSize); ! 486: READ_HIDDEN_CONFIG (MaxMemoryUsage); ! 487: ! 488: ! 489: // ! 490: // Now that we are completely configured, save the information ! 491: // in the registry. ! 492: // ! 493: ! 494: StSaveConfigInRegistry (ParametersHandle, ConfigurationInfo); ! 495: ! 496: ExFreePool (RegistryPathBuffer); ! 497: StCloseParametersKey (ParametersHandle); ! 498: ZwClose (StConfigHandle); ! 499: ! 500: return STATUS_SUCCESS; ! 501: ! 502: } /* StConfigureTransport */ ! 503: ! 504: ! 505: VOID ! 506: StFreeConfigurationInfo ( ! 507: IN PCONFIG_DATA ConfigurationInfo ! 508: ) ! 509: ! 510: /*++ ! 511: ! 512: Routine Description: ! 513: ! 514: This routine is called by ST to get free any storage that was allocated ! 515: by StConfigureTransport in producing the specified CONFIG_DATA structure. ! 516: ! 517: Arguments: ! 518: ! 519: ConfigurationInfo - A pointer to the configuration information structure. ! 520: ! 521: Return Value: ! 522: ! 523: None. ! 524: ! 525: --*/ ! 526: { ! 527: UINT i; ! 528: ! 529: for (i=0; i<ConfigurationInfo->NumAdapters; i++) { ! 530: RemoveAdapter (ConfigurationInfo, i); ! 531: RemoveDevice (ConfigurationInfo, i); ! 532: } ! 533: ExFreePool (ConfigurationInfo); ! 534: ! 535: } /* StFreeConfigurationInfo */ ! 536: ! 537: ! 538: NTSTATUS ! 539: StOpenParametersKey( ! 540: IN HANDLE StConfigHandle, ! 541: OUT PHANDLE ParametersHandle ! 542: ) ! 543: ! 544: /*++ ! 545: ! 546: Routine Description: ! 547: ! 548: This routine is called by ST to open the ST "Parameters" key. ! 549: ! 550: Arguments: ! 551: ! 552: ParametersHandle - Returns the handle used to read parameters. ! 553: ! 554: Return Value: ! 555: ! 556: The status of the request. ! 557: ! 558: --*/ ! 559: { ! 560: ! 561: NTSTATUS Status; ! 562: HANDLE ParamHandle; ! 563: PWSTR ParametersString = L"Parameters"; ! 564: UNICODE_STRING ParametersKeyName; ! 565: OBJECT_ATTRIBUTES TmpObjectAttributes; ! 566: ! 567: // ! 568: // Open the ST parameters key. ! 569: // ! 570: ! 571: RtlInitUnicodeString (&ParametersKeyName, ParametersString); ! 572: ! 573: InitializeObjectAttributes( ! 574: &TmpObjectAttributes, ! 575: &ParametersKeyName, // name ! 576: OBJ_CASE_INSENSITIVE, // attributes ! 577: StConfigHandle, // root ! 578: NULL // security descriptor ! 579: ); ! 580: ! 581: ! 582: Status = ZwOpenKey( ! 583: &ParamHandle, ! 584: KEY_READ, ! 585: &TmpObjectAttributes); ! 586: ! 587: if (!NT_SUCCESS(Status)) { ! 588: ! 589: StPrint1("Could not open parameters key: %lx\n", Status); ! 590: return Status; ! 591: ! 592: } ! 593: ! 594: *ParametersHandle = ParamHandle; ! 595: ! 596: ! 597: // ! 598: // All keys successfully opened or created. ! 599: // ! 600: ! 601: return STATUS_SUCCESS; ! 602: ! 603: } /* StOpenParametersKey */ ! 604: ! 605: VOID ! 606: StCloseParametersKey( ! 607: IN HANDLE ParametersHandle ! 608: ) ! 609: ! 610: /*++ ! 611: ! 612: Routine Description: ! 613: ! 614: This routine is called by ST to close the "Parameters" key. ! 615: It closes the handles passed in and does any other work needed. ! 616: ! 617: Arguments: ! 618: ! 619: ParametersHandle - The handle used to read other parameters. ! 620: ! 621: Return Value: ! 622: ! 623: None. ! 624: ! 625: --*/ ! 626: ! 627: { ! 628: ! 629: ZwClose (ParametersHandle); ! 630: ! 631: } /* StCloseParametersKey */ ! 632: ! 633: ! 634: NTSTATUS ! 635: StCountEntries( ! 636: IN PWSTR ValueName, ! 637: IN ULONG ValueType, ! 638: IN PVOID ValueData, ! 639: IN ULONG ValueLength, ! 640: IN PVOID Context, ! 641: IN PVOID EntryContext ! 642: ) ! 643: ! 644: /*++ ! 645: ! 646: Routine Description: ! 647: ! 648: This routine is a callback routine for RtlQueryRegistryValues ! 649: It is called with the "Bind" and "Export" multi-strings. ! 650: It counts the number of name entries required in the ! 651: CONFIGURATION_DATA structure and then allocates it. ! 652: ! 653: Arguments: ! 654: ! 655: ValueName - The name of the value ("Bind" or "Export" -- ignored). ! 656: ! 657: ValueType - The type of the value (REG_MULTI_SZ -- ignored). ! 658: ! 659: ValueData - The null-terminated data for the value. ! 660: ! 661: ValueLength - The length of ValueData (ignored). ! 662: ! 663: Context - A pointer to a pointer to the ConfigurationInfo structure. ! 664: When the "Export" callback is made this is filled in ! 665: with the allocate structure. ! 666: ! 667: EntryContext - A pointer to a counter holding the total number ! 668: of name entries required. ! 669: ! 670: Return Value: ! 671: ! 672: STATUS_SUCCESS ! 673: ! 674: --*/ ! 675: ! 676: { ! 677: ULONG StringCount; ! 678: PWCHAR ValuePointer = (PWCHAR)ValueData; ! 679: PCONFIG_DATA * ConfigurationInfo = (PCONFIG_DATA *)Context; ! 680: PULONG TotalCount = ((PULONG)EntryContext); ! 681: ULONG OldTotalCount = *TotalCount; ! 682: ! 683: ASSERT (ValueType == REG_MULTI_SZ); ! 684: ! 685: // ! 686: // Count the number of strings in the multi-string; first ! 687: // check that it is NULL-terminated to make the rest ! 688: // easier. ! 689: // ! 690: ! 691: if ((ValueLength < 2) || ! 692: (ValuePointer[(ValueLength/2)-1] != (WCHAR)'\0')) { ! 693: return STATUS_INVALID_PARAMETER; ! 694: } ! 695: ! 696: StringCount = 0; ! 697: while (*ValuePointer != (WCHAR)'\0') { ! 698: while (*ValuePointer != (WCHAR)'\0') { ! 699: ++ValuePointer; ! 700: } ! 701: ++StringCount; ! 702: ++ValuePointer; ! 703: if ((ULONG)((PUCHAR)ValuePointer - (PUCHAR)ValueData) >= ValueLength) { ! 704: break; ! 705: } ! 706: } ! 707: ! 708: (*TotalCount) += StringCount; ! 709: ! 710: if (*ValueName == (WCHAR)'E') { ! 711: ! 712: // ! 713: // This is "Export", allocate the config data structure. ! 714: // ! 715: ! 716: *ConfigurationInfo = ExAllocatePool( ! 717: NonPagedPool, ! 718: sizeof (CONFIG_DATA) + ! 719: ((*TotalCount-1) * sizeof(NDIS_STRING))); ! 720: ! 721: if (*ConfigurationInfo == NULL) { ! 722: return STATUS_INSUFFICIENT_RESOURCES; ! 723: } ! 724: ! 725: RtlZeroMemory( ! 726: *ConfigurationInfo, ! 727: sizeof(CONFIG_DATA) + ((*TotalCount-1) * sizeof(NDIS_STRING))); ! 728: ! 729: (*ConfigurationInfo)->DevicesOffset = OldTotalCount; ! 730: ! 731: } ! 732: ! 733: return STATUS_SUCCESS; ! 734: ! 735: } /* StCountEntries */ ! 736: ! 737: ! 738: NTSTATUS ! 739: StAddBind( ! 740: IN PWSTR ValueName, ! 741: IN ULONG ValueType, ! 742: IN PVOID ValueData, ! 743: IN ULONG ValueLength, ! 744: IN PVOID Context, ! 745: IN PVOID EntryContext ! 746: ) ! 747: ! 748: /*++ ! 749: ! 750: Routine Description: ! 751: ! 752: This routine is a callback routine for RtlQueryRegistryValues ! 753: It is called for each piece of the "Bind" multi-string and ! 754: saves the information in a ConfigurationInfo structure. ! 755: ! 756: Arguments: ! 757: ! 758: ValueName - The name of the value ("Bind" -- ignored). ! 759: ! 760: ValueType - The type of the value (REG_SZ -- ignored). ! 761: ! 762: ValueData - The null-terminated data for the value. ! 763: ! 764: ValueLength - The length of ValueData (ignored). ! 765: ! 766: Context - A pointer to the ConfigurationInfo structure. ! 767: ! 768: EntryContext - A pointer to a count of binds that is incremented. ! 769: ! 770: Return Value: ! 771: ! 772: STATUS_SUCCESS ! 773: ! 774: --*/ ! 775: ! 776: { ! 777: PCONFIG_DATA ConfigurationInfo = *(PCONFIG_DATA *)Context; ! 778: PULONG CurBindNum = ((PULONG)EntryContext); ! 779: ! 780: UNREFERENCED_PARAMETER(ValueName); ! 781: UNREFERENCED_PARAMETER(ValueType); ! 782: UNREFERENCED_PARAMETER(ValueLength); ! 783: ! 784: InsertAdapter( ! 785: ConfigurationInfo, ! 786: *CurBindNum, ! 787: (PWSTR)(ValueData)); ! 788: ! 789: ++(*CurBindNum); ! 790: ! 791: return STATUS_SUCCESS; ! 792: ! 793: } /* StAddBind */ ! 794: ! 795: ! 796: NTSTATUS ! 797: StAddExport( ! 798: IN PWSTR ValueName, ! 799: IN ULONG ValueType, ! 800: IN PVOID ValueData, ! 801: IN ULONG ValueLength, ! 802: IN PVOID Context, ! 803: IN PVOID EntryContext ! 804: ) ! 805: ! 806: /*++ ! 807: ! 808: Routine Description: ! 809: ! 810: This routine is a callback routine for RtlQueryRegistryValues ! 811: It is called for each piece of the "Export" multi-string and ! 812: saves the information in a ConfigurationInfo structure. ! 813: ! 814: Arguments: ! 815: ! 816: ValueName - The name of the value ("Export" -- ignored). ! 817: ! 818: ValueType - The type of the value (REG_SZ -- ignored). ! 819: ! 820: ValueData - The null-terminated data for the value. ! 821: ! 822: ValueLength - The length of ValueData (ignored). ! 823: ! 824: Context - A pointer to the ConfigurationInfo structure. ! 825: ! 826: EntryContext - A pointer to a count of exports that is incremented. ! 827: ! 828: Return Value: ! 829: ! 830: STATUS_SUCCESS ! 831: ! 832: --*/ ! 833: ! 834: { ! 835: PCONFIG_DATA ConfigurationInfo = *(PCONFIG_DATA *)Context; ! 836: PULONG CurExportNum = ((PULONG)EntryContext); ! 837: ! 838: UNREFERENCED_PARAMETER(ValueName); ! 839: UNREFERENCED_PARAMETER(ValueType); ! 840: UNREFERENCED_PARAMETER(ValueLength); ! 841: ! 842: InsertDevice( ! 843: ConfigurationInfo, ! 844: *CurExportNum, ! 845: (PWSTR)(ValueData)); ! 846: ! 847: ++(*CurExportNum); ! 848: ! 849: return STATUS_SUCCESS; ! 850: ! 851: } /* StAddExport */ ! 852: ! 853: ! 854: VOID ! 855: StReadLinkageInformation( ! 856: IN PWSTR RegistryPathBuffer, ! 857: IN PCONFIG_DATA * ConfigurationInfo ! 858: ) ! 859: ! 860: /*++ ! 861: ! 862: Routine Description: ! 863: ! 864: This routine is called by ST to read its linkage information ! 865: from the registry. If there is none present, then ConfigData ! 866: is filled with a list of all the adapters that are known ! 867: to ST. ! 868: ! 869: Arguments: ! 870: ! 871: RegistryPathBuffer - The null-terminated root of the ST registry tree. ! 872: ! 873: ConfigurationInfo - Returns ST's current configuration. ! 874: ! 875: Return Value: ! 876: ! 877: None. ! 878: ! 879: --*/ ! 880: ! 881: { ! 882: ! 883: UINT ConfigBindings; ! 884: UINT NameCount = 0; ! 885: NTSTATUS Status; ! 886: RTL_QUERY_REGISTRY_TABLE QueryTable[6]; ! 887: PWSTR Subkey = L"Linkage"; ! 888: PWSTR Bind = L"Bind"; ! 889: PWSTR Export = L"Export"; ! 890: ULONG BindCount, ExportCount; ! 891: UINT i; ! 892: ! 893: ! 894: // ! 895: // Set up QueryTable to do the following: ! 896: // ! 897: ! 898: // ! 899: // 1) Switch to the Linkage key below ST ! 900: // ! 901: ! 902: QueryTable[0].QueryRoutine = NULL; ! 903: QueryTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY; ! 904: QueryTable[0].Name = Subkey; ! 905: ! 906: // ! 907: // 2) Call StCountEntries for the "Bind" multi-string ! 908: // ! 909: ! 910: QueryTable[1].QueryRoutine = StCountEntries; ! 911: QueryTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND; ! 912: QueryTable[1].Name = Bind; ! 913: QueryTable[1].EntryContext = (PVOID)&NameCount; ! 914: QueryTable[1].DefaultType = REG_NONE; ! 915: ! 916: // ! 917: // 3) Call StCountEntries for the "Export" multi-string ! 918: // ! 919: ! 920: QueryTable[2].QueryRoutine = StCountEntries; ! 921: QueryTable[2].Flags = RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_NOEXPAND; ! 922: QueryTable[2].Name = Export; ! 923: QueryTable[2].EntryContext = (PVOID)&NameCount; ! 924: QueryTable[2].DefaultType = REG_NONE; ! 925: ! 926: // ! 927: // 4) Call StAddBind for each string in "Bind" ! 928: // ! 929: ! 930: QueryTable[3].QueryRoutine = StAddBind; ! 931: QueryTable[3].Flags = 0; ! 932: QueryTable[3].Name = Bind; ! 933: QueryTable[3].EntryContext = (PVOID)&BindCount; ! 934: QueryTable[3].DefaultType = REG_NONE; ! 935: ! 936: // ! 937: // 5) Call StAddExport for each string in "Export" ! 938: // ! 939: ! 940: QueryTable[4].QueryRoutine = StAddExport; ! 941: QueryTable[4].Flags = 0; ! 942: QueryTable[4].Name = Export; ! 943: QueryTable[4].EntryContext = (PVOID)&ExportCount; ! 944: QueryTable[4].DefaultType = REG_NONE; ! 945: ! 946: // ! 947: // 6) Stop ! 948: // ! 949: ! 950: QueryTable[5].QueryRoutine = NULL; ! 951: QueryTable[5].Flags = 0; ! 952: QueryTable[5].Name = NULL; ! 953: ! 954: ! 955: BindCount = 0; ! 956: ExportCount = 0; ! 957: ! 958: Status = RtlQueryRegistryValues( ! 959: RTL_REGISTRY_ABSOLUTE, ! 960: RegistryPathBuffer, ! 961: QueryTable, ! 962: (PVOID)ConfigurationInfo, ! 963: NULL); ! 964: ! 965: if (Status != STATUS_SUCCESS) { ! 966: return; ! 967: } ! 968: ! 969: // ! 970: // Make sure that BindCount and ExportCount match, if not ! 971: // remove the extras. ! 972: // ! 973: ! 974: if (BindCount < ExportCount) { ! 975: ! 976: for (i=BindCount; i<ExportCount; i++) { ! 977: RemoveDevice (*ConfigurationInfo, i); ! 978: } ! 979: ConfigBindings = BindCount; ! 980: ! 981: } else if (ExportCount < BindCount) { ! 982: ! 983: for (i=ExportCount; i<BindCount; i++) { ! 984: RemoveAdapter (*ConfigurationInfo, i); ! 985: } ! 986: ConfigBindings = ExportCount; ! 987: ! 988: } else { ! 989: ! 990: ConfigBindings = BindCount; // which is equal to ExportCount ! 991: ! 992: } ! 993: ! 994: (*ConfigurationInfo)->NumAdapters = ConfigBindings; ! 995: ! 996: } /* StReadLinkageInformation */ ! 997: ! 998: ! 999: UINT ! 1000: StReadSizeInformation( ! 1001: IN HANDLE ParametersHandle ! 1002: ) ! 1003: ! 1004: /*++ ! 1005: ! 1006: Routine Description: ! 1007: ! 1008: This routine is called by ST to read the Size information ! 1009: from the registry. ! 1010: ! 1011: Arguments: ! 1012: ! 1013: RegistryHandle - A pointer to the open registry. ! 1014: ! 1015: Return Value: ! 1016: ! 1017: 0 - no Size specified ! 1018: 1 - Small ! 1019: 2 - Medium ! 1020: 3 - Big / Large ! 1021: ! 1022: --*/ ! 1023: ! 1024: { ! 1025: ! 1026: UINT SizeToReturn; ! 1027: // STRING KeywordName; ! 1028: // PCONFIG_KEYWORD Keyword; ! 1029: ! 1030: ULONG InformationBuffer[16]; // declare ULONG to get it aligned ! 1031: PKEY_VALUE_FULL_INFORMATION Information = ! 1032: (PKEY_VALUE_FULL_INFORMATION)InformationBuffer; ! 1033: ULONG InformationLength; ! 1034: WCHAR SizeString[] = L"Size"; ! 1035: UNICODE_STRING SizeValueName; ! 1036: NTSTATUS Status; ! 1037: PUCHAR InformationData; ! 1038: ULONG InformationLong; ! 1039: ! 1040: ! 1041: // ! 1042: // Read the size parameter out of the registry. ! 1043: // ! 1044: ! 1045: RtlInitUnicodeString (&SizeValueName, SizeString); ! 1046: ! 1047: Status = ZwQueryValueKey( ! 1048: ParametersHandle, ! 1049: &SizeValueName, ! 1050: KeyValueFullInformation, ! 1051: (PVOID)Information, ! 1052: sizeof (InformationBuffer), ! 1053: &InformationLength); ! 1054: ! 1055: // ! 1056: // Compare to the expected values. ! 1057: // ! 1058: ! 1059: if (Status == STATUS_SUCCESS) { ! 1060: ! 1061: InformationData = ((PUCHAR)Information) + Information->DataOffset; ! 1062: InformationLong = *((PULONG)InformationData); ! 1063: ! 1064: if ((Information->DataLength == sizeof(ULONG)) && ! 1065: (InformationLong >= 1 && InformationLong <= 3)) { ! 1066: ! 1067: SizeToReturn = InformationLong; ! 1068: ! 1069: } else { ! 1070: ! 1071: if ((Information->DataLength >= 10) && ! 1072: (RtlCompareMemory (StrLarge, InformationData, 10) == 10)) { ! 1073: ! 1074: SizeToReturn = 3; ! 1075: ! 1076: } else if ((Information->DataLength >= 12) && ! 1077: (RtlCompareMemory (StrMedium, InformationData, 12) == 12)) { ! 1078: ! 1079: SizeToReturn = 2; ! 1080: ! 1081: } else if ((Information->DataLength >= 10) && ! 1082: (RtlCompareMemory (StrSmall, InformationData, 10) == 10)) { ! 1083: ! 1084: SizeToReturn = 1; ! 1085: ! 1086: } else { ! 1087: ! 1088: SizeToReturn = 0; ! 1089: ! 1090: } ! 1091: ! 1092: } ! 1093: ! 1094: } else { ! 1095: ! 1096: SizeToReturn = 0; ! 1097: ! 1098: } ! 1099: ! 1100: return SizeToReturn; ! 1101: ! 1102: } /* StReadSizeInformation */ ! 1103: ! 1104: ! 1105: ULONG ! 1106: StReadSingleParameter( ! 1107: IN HANDLE ParametersHandle, ! 1108: IN PWCHAR ValueName, ! 1109: IN ULONG DefaultValue ! 1110: ) ! 1111: ! 1112: /*++ ! 1113: ! 1114: Routine Description: ! 1115: ! 1116: This routine is called by ST to read a single parameter ! 1117: from the registry. If the parameter is found it is stored ! 1118: in Data. ! 1119: ! 1120: Arguments: ! 1121: ! 1122: ParametersHandle - A pointer to the open registry. ! 1123: ! 1124: ValueName - The name of the value to search for. ! 1125: ! 1126: DefaultValue - The default value. ! 1127: ! 1128: Return Value: ! 1129: ! 1130: The value to use; will be the default if the value is not ! 1131: found or is not in the correct range. ! 1132: ! 1133: --*/ ! 1134: ! 1135: { ! 1136: ULONG InformationBuffer[16]; // declare ULONG to get it aligned ! 1137: PKEY_VALUE_FULL_INFORMATION Information = ! 1138: (PKEY_VALUE_FULL_INFORMATION)InformationBuffer; ! 1139: UNICODE_STRING ValueKeyName; ! 1140: ULONG InformationLength; ! 1141: ULONG ReturnValue; ! 1142: NTSTATUS Status; ! 1143: ! 1144: RtlInitUnicodeString (&ValueKeyName, ValueName); ! 1145: ! 1146: Status = ZwQueryValueKey( ! 1147: ParametersHandle, ! 1148: &ValueKeyName, ! 1149: KeyValueFullInformation, ! 1150: (PVOID)Information, ! 1151: sizeof (InformationBuffer), ! 1152: &InformationLength); ! 1153: ! 1154: if ((Status == STATUS_SUCCESS) && (Information->DataLength == sizeof(ULONG))) { ! 1155: ! 1156: RtlCopyMemory( ! 1157: (PVOID)&ReturnValue, ! 1158: ((PUCHAR)Information) + Information->DataOffset, ! 1159: sizeof(ULONG)); ! 1160: ! 1161: if (ReturnValue < 0) { ! 1162: ! 1163: ReturnValue = DefaultValue; ! 1164: ! 1165: } ! 1166: ! 1167: } else { ! 1168: ! 1169: ReturnValue = DefaultValue; ! 1170: ! 1171: } ! 1172: ! 1173: return ReturnValue; ! 1174: ! 1175: } /* StReadSingleParameter */ ! 1176: ! 1177: ! 1178: VOID ! 1179: StWriteSingleParameter( ! 1180: IN HANDLE ParametersHandle, ! 1181: IN PWCHAR ValueName, ! 1182: IN ULONG ValueData ! 1183: ) ! 1184: ! 1185: /*++ ! 1186: ! 1187: Routine Description: ! 1188: ! 1189: This routine is called by ST to write a single parameter ! 1190: from the registry. ! 1191: ! 1192: Arguments: ! 1193: ! 1194: ParametersHandle - A pointer to the open registry. ! 1195: ! 1196: ValueName - The name of the value to store. ! 1197: ! 1198: ValueData - The data to store at the value. ! 1199: ! 1200: Return Value: ! 1201: ! 1202: None. ! 1203: ! 1204: --*/ ! 1205: ! 1206: { ! 1207: UNICODE_STRING ValueKeyName; ! 1208: NTSTATUS Status; ! 1209: ULONG TmpValueData = ValueData; ! 1210: ! 1211: RtlInitUnicodeString (&ValueKeyName, ValueName); ! 1212: ! 1213: Status = ZwSetValueKey( ! 1214: ParametersHandle, ! 1215: &ValueKeyName, ! 1216: 0, ! 1217: REG_DWORD, ! 1218: (PVOID)&TmpValueData, ! 1219: sizeof(ULONG)); ! 1220: ! 1221: if (!NT_SUCCESS(Status)) { ! 1222: StPrint1("ST: Could not write dword key: %lx\n", Status); ! 1223: } ! 1224: ! 1225: } /* StWriteSingleParameter */ ! 1226: ! 1227: ! 1228: VOID ! 1229: StSaveConfigInRegistry( ! 1230: IN HANDLE ParametersHandle, ! 1231: IN PCONFIG_DATA ConfigurationInfo ! 1232: ) ! 1233: ! 1234: /*++ ! 1235: ! 1236: Routine Description: ! 1237: ! 1238: This routine is called by ST to save its configuraition ! 1239: information in the registry. It saves the information if ! 1240: the registry structure did not exist before this boot. ! 1241: ! 1242: Arguments: ! 1243: ! 1244: ParametersHandle - The handle used to read other parameters. ! 1245: ! 1246: ConfigurationInfo - Describes ST's current configuration. ! 1247: ! 1248: Return Value: ! 1249: ! 1250: None. ! 1251: ! 1252: --*/ ! 1253: ! 1254: { ! 1255: ! 1256: // ! 1257: // Save the "hidden" parameters, these may not exist in ! 1258: // the registry. ! 1259: // ! 1260: // NOTE: These macros expect "ConfigurationInfo" and ! 1261: // "ParametersHandle" to exist when they are expanded. ! 1262: // ! 1263: ! 1264: // ! 1265: // Don't write the parameters that are set ! 1266: // based on Size, since otherwise these will overwrite ! 1267: // those values since hidden parameters are set up ! 1268: // after the Size-based configuration is done. ! 1269: // ! 1270: ! 1271: WRITE_HIDDEN_CONFIG (MaxRequests); ! 1272: WRITE_HIDDEN_CONFIG (MaxConnections); ! 1273: WRITE_HIDDEN_CONFIG (MaxAddressFiles); ! 1274: WRITE_HIDDEN_CONFIG (MaxAddresses); ! 1275: ! 1276: } /* StSaveConfigInRegistry */ ! 1277:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.