Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

851 lines
20 KiB

  1. /* Copyright (c) 1992, Microsoft Corporation, all rights reserved
  2. **
  3. ** rasp.h
  4. ** Remote Access external API
  5. ** Private header for external API clients
  6. */
  7. #ifndef _RASP_H_
  8. #define _RASP_H_
  9. /* Trusted entry points used by RASPHONE.
  10. */
  11. HPORT APIENTRY RasGetHport( HRASCONN );
  12. HRASCONN APIENTRY RasGetHrasconn( HPORT );
  13. VOID APIENTRY RasGetConnectResponse( HRASCONN, CHAR* );
  14. DWORD APIENTRY RasSetNewPassword( HRASCONN, CHAR* );
  15. /*----------------------------------------------------------------------------
  16. ** Off-version ras.h definitions
  17. **----------------------------------------------------------------------------
  18. */
  19. #include "pshpack4.h"
  20. /* RAS structures as they appear to a caller in previous releases. These are
  21. ** defined here because RASAPI32 needs to be able to access both old and new
  22. ** definitions in the same code.
  23. */
  24. /* Windows NT 3.51 definitions.
  25. */
  26. #define RAS_MaxEntryName_V351 20
  27. #define RAS_MaxDeviceName_V351 32
  28. #define RAS_MaxCallbackNumber_V351 48
  29. /* Identifies an active RAS connection. (See RasEnumConnections)
  30. */
  31. #define RASCONNW_V351 struct tagRASCONNW_V351
  32. RASCONNW_V351
  33. {
  34. DWORD dwSize;
  35. HRASCONN hrasconn;
  36. WCHAR szEntryName[ RAS_MaxEntryName_V351 + 1 ];
  37. };
  38. #define RASCONNA_V351 struct tagRASCONNA_V351
  39. RASCONNA_V351
  40. {
  41. DWORD dwSize;
  42. HRASCONN hrasconn;
  43. CHAR szEntryName[ RAS_MaxEntryName_V351 + 1 ];
  44. };
  45. #define RASCONNW_V400 struct tagRASCONNW_V400
  46. RASCONNW_V400
  47. {
  48. DWORD dwSize;
  49. HRASCONN hrasconn;
  50. WCHAR szEntryName[ RAS_MaxEntryName + 1 ];
  51. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  52. WCHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  53. };
  54. #define RASCONNA_V400 struct tagRASCONNA_V400
  55. RASCONNA_V400
  56. {
  57. DWORD dwSize;
  58. HRASCONN hrasconn;
  59. CHAR szEntryName[ RAS_MaxEntryName + 1 ];
  60. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  61. CHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  62. };
  63. #define RASCONNA_V401 struct tagRASCONNA_V401
  64. RASCONNA_V401
  65. {
  66. DWORD dwSize;
  67. HRASCONN hrasconn;
  68. CHAR szEntryName[ RAS_MaxEntryName + 1 ];
  69. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  70. CHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  71. CHAR szPhonebook [ MAX_PATH ];
  72. DWORD dwSubEntry;
  73. };
  74. #define RASCONNW_V401 struct tagRASCONNW_V401
  75. RASCONNW_V401
  76. {
  77. DWORD dwSize;
  78. HRASCONN hrasconn;
  79. WCHAR szEntryName[ RAS_MaxEntryName + 1 ];
  80. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  81. WCHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  82. WCHAR szPhonebook [ MAX_PATH ];
  83. DWORD dwSubEntry;
  84. };
  85. #define RASCONNA_V500 struct tagRASCONNA_V500
  86. RASCONNA_V500
  87. {
  88. DWORD dwSize;
  89. HRASCONN hrasconn;
  90. CHAR szEntryName[ RAS_MaxEntryName + 1 ];
  91. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  92. CHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  93. CHAR szPhonebook [ MAX_PATH ];
  94. DWORD dwSubEntry;
  95. GUID guidEntry;
  96. };
  97. #define RASCONNW_V500 struct tagRASCONNW_V500
  98. RASCONNW_V500
  99. {
  100. DWORD dwSize;
  101. HRASCONN hrasconn;
  102. WCHAR szEntryName[ RAS_MaxEntryName + 1 ];
  103. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  104. WCHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  105. WCHAR szPhonebook [ MAX_PATH ];
  106. DWORD dwSubEntry;
  107. GUID guidEntry;
  108. };
  109. /* Describes the status of a RAS connection. (See RasConnectionStatus)
  110. */
  111. #define RASCONNSTATUSW_V351 struct tagRASCONNSTATUSW_V351
  112. RASCONNSTATUSW_V351
  113. {
  114. DWORD dwSize;
  115. RASCONNSTATE rasconnstate;
  116. DWORD dwError;
  117. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  118. WCHAR szDeviceName[ RAS_MaxDeviceName_V351 + 1 ];
  119. };
  120. #define RASCONNSTATUSA_V351 struct tagRASCONNSTATUSA_V351
  121. RASCONNSTATUSA_V351
  122. {
  123. DWORD dwSize;
  124. RASCONNSTATE rasconnstate;
  125. DWORD dwError;
  126. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  127. CHAR szDeviceName[ RAS_MaxDeviceName_V351 + 1 ];
  128. };
  129. #define RASCONNSTATUSW_V400 struct tagRASCONNSTATUSW_V400
  130. RASCONNSTATUSW_V400
  131. {
  132. DWORD dwSize;
  133. RASCONNSTATE rasconnstate;
  134. DWORD dwError;
  135. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  136. WCHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  137. };
  138. #define RASCONNSTATUSA_V400 struct tagRASCONNSTATUSA_V400
  139. RASCONNSTATUSA_V400
  140. {
  141. DWORD dwSize;
  142. RASCONNSTATE rasconnstate;
  143. DWORD dwError;
  144. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  145. CHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  146. };
  147. /* Describes connection establishment parameters. (See RasDial)
  148. */
  149. #define RASDIALPARAMSW_V351 struct tagRASDIALPARAMSW_V351
  150. RASDIALPARAMSW_V351
  151. {
  152. DWORD dwSize;
  153. WCHAR szEntryName[ RAS_MaxEntryName_V351 + 1 ];
  154. WCHAR szPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  155. WCHAR szCallbackNumber[ RAS_MaxCallbackNumber_V351 + 1 ];
  156. WCHAR szUserName[ UNLEN + 1 ];
  157. WCHAR szPassword[ PWLEN + 1 ];
  158. WCHAR szDomain[ DNLEN + 1 ];
  159. };
  160. #define RASDIALPARAMSA_V351 struct tagRASDIALPARAMSA_V351
  161. RASDIALPARAMSA_V351
  162. {
  163. DWORD dwSize;
  164. CHAR szEntryName[ RAS_MaxEntryName_V351 + 1 ];
  165. CHAR szPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  166. CHAR szCallbackNumber[ RAS_MaxCallbackNumber_V351 + 1 ];
  167. CHAR szUserName[ UNLEN + 1 ];
  168. CHAR szPassword[ PWLEN + 1 ];
  169. CHAR szDomain[ DNLEN + 1 ];
  170. };
  171. #define RASDIALPARAMSW_V400 struct tagRASDIALPARAMSW_V400
  172. RASDIALPARAMSW_V400
  173. {
  174. DWORD dwSize;
  175. WCHAR szEntryName[ RAS_MaxEntryName + 1 ];
  176. WCHAR szPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  177. WCHAR szCallbackNumber[ RAS_MaxCallbackNumber + 1 ];
  178. WCHAR szUserName[ UNLEN + 1 ];
  179. WCHAR szPassword[ PWLEN + 1 ];
  180. WCHAR szDomain[ DNLEN + 1 ];
  181. };
  182. #define RASDIALPARAMSA_V400 struct tagRASDIALPARAMSA_V400
  183. RASDIALPARAMSA_V400
  184. {
  185. DWORD dwSize;
  186. CHAR szEntryName[ RAS_MaxEntryName + 1 ];
  187. CHAR szPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  188. CHAR szCallbackNumber[ RAS_MaxCallbackNumber + 1 ];
  189. CHAR szUserName[ UNLEN + 1 ];
  190. CHAR szPassword[ PWLEN + 1 ];
  191. CHAR szDomain[ DNLEN + 1 ];
  192. };
  193. /* Describes an enumerated RAS phone book entry name. (See RasEntryEnum)
  194. */
  195. #define RASENTRYNAMEW_V351 struct tagRASENTRYNAMEW_V351
  196. RASENTRYNAMEW_V351
  197. {
  198. DWORD dwSize;
  199. WCHAR szEntryName[ RAS_MaxEntryName_V351 + 1 ];
  200. };
  201. #define RASENTRYNAMEA_V351 struct tagRASENTRYNAMEA_V351
  202. RASENTRYNAMEA_V351
  203. {
  204. DWORD dwSize;
  205. CHAR szEntryName[ RAS_MaxEntryName_V351 + 1 ];
  206. };
  207. #define RASENTRYNAMEW_V401 struct tagRASENTRYNAMEW_V401
  208. RASENTRYNAMEW_V401
  209. {
  210. DWORD dwSize;
  211. WCHAR szEntryName[ RAS_MaxEntryName + 1 ];
  212. };
  213. #define RASENTRYNAMEA_V401 struct tagRASENTRYNAMEA_V401
  214. RASENTRYNAMEA_V401
  215. {
  216. DWORD dwSize;
  217. CHAR szEntryName[ RAS_MaxEntryName + 1 ];
  218. };
  219. /* A RAS phone book entry.
  220. */
  221. #define RASENTRYW_V400 struct tagRASENTRYW_V400
  222. RASENTRYW_V400
  223. {
  224. DWORD dwSize;
  225. DWORD dwfOptions;
  226. //
  227. // Location/phone number
  228. //
  229. DWORD dwCountryID;
  230. DWORD dwCountryCode;
  231. WCHAR szAreaCode[ RAS_MaxAreaCode + 1 ];
  232. WCHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  233. DWORD dwAlternateOffset;
  234. //
  235. // PPP/Ip
  236. //
  237. RASIPADDR ipaddr;
  238. RASIPADDR ipaddrDns;
  239. RASIPADDR ipaddrDnsAlt;
  240. RASIPADDR ipaddrWins;
  241. RASIPADDR ipaddrWinsAlt;
  242. //
  243. // Framing
  244. //
  245. DWORD dwFrameSize;
  246. DWORD dwfNetProtocols;
  247. DWORD dwFramingProtocol;
  248. //
  249. // Scripting
  250. //
  251. WCHAR szScript[ MAX_PATH ];
  252. //
  253. // AutoDial
  254. //
  255. WCHAR szAutodialDll[ MAX_PATH ];
  256. WCHAR szAutodialFunc[ MAX_PATH ];
  257. //
  258. // Device
  259. //
  260. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  261. WCHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  262. //
  263. // X.25
  264. //
  265. WCHAR szX25PadType[ RAS_MaxPadType + 1 ];
  266. WCHAR szX25Address[ RAS_MaxX25Address + 1 ];
  267. WCHAR szX25Facilities[ RAS_MaxFacilities + 1 ];
  268. WCHAR szX25UserData[ RAS_MaxUserData + 1 ];
  269. DWORD dwChannels;
  270. //
  271. // Reserved
  272. //
  273. DWORD dwReserved1;
  274. DWORD dwReserved2;
  275. };
  276. #define RASENTRYA_V400 struct tagRASENTRYA_V400
  277. RASENTRYA_V400
  278. {
  279. DWORD dwSize;
  280. DWORD dwfOptions;
  281. //
  282. // Location/phone number.
  283. //
  284. DWORD dwCountryID;
  285. DWORD dwCountryCode;
  286. CHAR szAreaCode[ RAS_MaxAreaCode + 1 ];
  287. CHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  288. DWORD dwAlternateOffset;
  289. //
  290. // PPP/Ip
  291. //
  292. RASIPADDR ipaddr;
  293. RASIPADDR ipaddrDns;
  294. RASIPADDR ipaddrDnsAlt;
  295. RASIPADDR ipaddrWins;
  296. RASIPADDR ipaddrWinsAlt;
  297. //
  298. // Framing
  299. //
  300. DWORD dwFrameSize;
  301. DWORD dwfNetProtocols;
  302. DWORD dwFramingProtocol;
  303. //
  304. // Scripting
  305. //
  306. CHAR szScript[ MAX_PATH ];
  307. //
  308. // AutoDial
  309. //
  310. CHAR szAutodialDll[ MAX_PATH ];
  311. CHAR szAutodialFunc[ MAX_PATH ];
  312. //
  313. // Device
  314. //
  315. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  316. CHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  317. //
  318. // X.25
  319. //
  320. CHAR szX25PadType[ RAS_MaxPadType + 1 ];
  321. CHAR szX25Address[ RAS_MaxX25Address + 1 ];
  322. CHAR szX25Facilities[ RAS_MaxFacilities + 1 ];
  323. CHAR szX25UserData[ RAS_MaxUserData + 1 ];
  324. DWORD dwChannels;
  325. //
  326. // Reserved
  327. //
  328. DWORD dwReserved1;
  329. DWORD dwReserved2;
  330. };
  331. /* A RAS phone book entry (v401)
  332. */
  333. #define RASENTRYA_V401 struct tagRASENTRYA_V401
  334. RASENTRYA_V401
  335. {
  336. DWORD dwSize;
  337. DWORD dwfOptions;
  338. //
  339. // Location/phone number.
  340. //
  341. DWORD dwCountryID;
  342. DWORD dwCountryCode;
  343. CHAR szAreaCode[ RAS_MaxAreaCode + 1 ];
  344. CHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  345. DWORD dwAlternateOffset;
  346. //
  347. // PPP/Ip
  348. //
  349. RASIPADDR ipaddr;
  350. RASIPADDR ipaddrDns;
  351. RASIPADDR ipaddrDnsAlt;
  352. RASIPADDR ipaddrWins;
  353. RASIPADDR ipaddrWinsAlt;
  354. //
  355. // Framing
  356. //
  357. DWORD dwFrameSize;
  358. DWORD dwfNetProtocols;
  359. DWORD dwFramingProtocol;
  360. //
  361. // Scripting
  362. //
  363. CHAR szScript[ MAX_PATH ];
  364. //
  365. // AutoDial
  366. //
  367. CHAR szAutodialDll[ MAX_PATH ];
  368. CHAR szAutodialFunc[ MAX_PATH ];
  369. //
  370. // Device
  371. //
  372. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  373. CHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  374. //
  375. // X.25
  376. //
  377. CHAR szX25PadType[ RAS_MaxPadType + 1 ];
  378. CHAR szX25Address[ RAS_MaxX25Address + 1 ];
  379. CHAR szX25Facilities[ RAS_MaxFacilities + 1 ];
  380. CHAR szX25UserData[ RAS_MaxUserData + 1 ];
  381. DWORD dwChannels;
  382. //
  383. // Reserved
  384. //
  385. DWORD dwReserved1;
  386. DWORD dwReserved2;
  387. //
  388. // Multilink
  389. //
  390. DWORD dwSubEntries;
  391. DWORD dwDialMode;
  392. DWORD dwDialExtraPercent;
  393. DWORD dwDialExtraSampleSeconds;
  394. DWORD dwHangUpExtraPercent;
  395. DWORD dwHangUpExtraSampleSeconds;
  396. //
  397. // Idle timeout
  398. //
  399. DWORD dwIdleDisconnectSeconds;
  400. };
  401. #define RASENTRYW_V401 struct tagRASENTRYW_V401
  402. RASENTRYW_V401
  403. {
  404. DWORD dwSize;
  405. DWORD dwfOptions;
  406. //
  407. // Location/phone number
  408. //
  409. DWORD dwCountryID;
  410. DWORD dwCountryCode;
  411. WCHAR szAreaCode[ RAS_MaxAreaCode + 1 ];
  412. WCHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  413. DWORD dwAlternateOffset;
  414. //
  415. // PPP/Ip
  416. //
  417. RASIPADDR ipaddr;
  418. RASIPADDR ipaddrDns;
  419. RASIPADDR ipaddrDnsAlt;
  420. RASIPADDR ipaddrWins;
  421. RASIPADDR ipaddrWinsAlt;
  422. //
  423. // Framing
  424. //
  425. DWORD dwFrameSize;
  426. DWORD dwfNetProtocols;
  427. DWORD dwFramingProtocol;
  428. //
  429. // Scripting
  430. //
  431. WCHAR szScript[ MAX_PATH ];
  432. //
  433. // AutoDial
  434. //
  435. WCHAR szAutodialDll[ MAX_PATH ];
  436. WCHAR szAutodialFunc[ MAX_PATH ];
  437. //
  438. // Device
  439. //
  440. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  441. WCHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  442. //
  443. // X.25
  444. //
  445. WCHAR szX25PadType[ RAS_MaxPadType + 1 ];
  446. WCHAR szX25Address[ RAS_MaxX25Address + 1 ];
  447. WCHAR szX25Facilities[ RAS_MaxFacilities + 1 ];
  448. WCHAR szX25UserData[ RAS_MaxUserData + 1 ];
  449. DWORD dwChannels;
  450. //
  451. // Reserved
  452. //
  453. DWORD dwReserved1;
  454. DWORD dwReserved2;
  455. //
  456. // Multilink
  457. //
  458. DWORD dwSubEntries;
  459. DWORD dwDialMode;
  460. DWORD dwDialExtraPercent;
  461. DWORD dwDialExtraSampleSeconds;
  462. DWORD dwHangUpExtraPercent;
  463. DWORD dwHangUpExtraSampleSeconds;
  464. //
  465. // Idle timeout
  466. //
  467. DWORD dwIdleDisconnectSeconds;
  468. };
  469. #define RASENTRYA_V500 struct tagRASENTRYA_V500
  470. RASENTRYA_V500
  471. {
  472. DWORD dwSize;
  473. DWORD dwfOptions;
  474. //
  475. // Location/phone number.
  476. //
  477. DWORD dwCountryID;
  478. DWORD dwCountryCode;
  479. CHAR szAreaCode[ RAS_MaxAreaCode + 1 ];
  480. CHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  481. DWORD dwAlternateOffset;
  482. //
  483. // PPP/Ip
  484. //
  485. RASIPADDR ipaddr;
  486. RASIPADDR ipaddrDns;
  487. RASIPADDR ipaddrDnsAlt;
  488. RASIPADDR ipaddrWins;
  489. RASIPADDR ipaddrWinsAlt;
  490. //
  491. // Framing
  492. //
  493. DWORD dwFrameSize;
  494. DWORD dwfNetProtocols;
  495. DWORD dwFramingProtocol;
  496. //
  497. // Scripting
  498. //
  499. CHAR szScript[ MAX_PATH ];
  500. //
  501. // AutoDial
  502. //
  503. CHAR szAutodialDll[ MAX_PATH ];
  504. CHAR szAutodialFunc[ MAX_PATH ];
  505. //
  506. // Device
  507. //
  508. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  509. CHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  510. //
  511. // X.25
  512. //
  513. CHAR szX25PadType[ RAS_MaxPadType + 1 ];
  514. CHAR szX25Address[ RAS_MaxX25Address + 1 ];
  515. CHAR szX25Facilities[ RAS_MaxFacilities + 1 ];
  516. CHAR szX25UserData[ RAS_MaxUserData + 1 ];
  517. DWORD dwChannels;
  518. //
  519. // Reserved
  520. //
  521. DWORD dwReserved1;
  522. DWORD dwReserved2;
  523. #if (WINVER >= 0x401)
  524. //
  525. // Multilink
  526. //
  527. DWORD dwSubEntries;
  528. DWORD dwDialMode;
  529. DWORD dwDialExtraPercent;
  530. DWORD dwDialExtraSampleSeconds;
  531. DWORD dwHangUpExtraPercent;
  532. DWORD dwHangUpExtraSampleSeconds;
  533. //
  534. // Idle timeout
  535. //
  536. DWORD dwIdleDisconnectSeconds;
  537. #endif
  538. #if (WINVER >= 0x500)
  539. //
  540. // Entry Type
  541. //
  542. DWORD dwType;
  543. //
  544. // Encryption type
  545. //
  546. DWORD dwEncryptionType;
  547. //
  548. // CustomAuthKey to be used for EAP
  549. //
  550. DWORD dwCustomAuthKey;
  551. //
  552. // Guid of the connection
  553. //
  554. GUID guidId;
  555. //
  556. // Custom Dial Dll
  557. //
  558. CHAR szCustomDialDll[MAX_PATH];
  559. //
  560. // DwVpnStrategy
  561. //
  562. DWORD dwVpnStrategy;
  563. #endif
  564. };
  565. #define RASENTRYW_V500 struct tagRASENTRYW_V500
  566. RASENTRYW_V500
  567. {
  568. DWORD dwSize;
  569. DWORD dwfOptions;
  570. //
  571. // Location/phone number
  572. //
  573. DWORD dwCountryID;
  574. DWORD dwCountryCode;
  575. WCHAR szAreaCode[ RAS_MaxAreaCode + 1 ];
  576. WCHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  577. DWORD dwAlternateOffset;
  578. //
  579. // PPP/Ip
  580. //
  581. RASIPADDR ipaddr;
  582. RASIPADDR ipaddrDns;
  583. RASIPADDR ipaddrDnsAlt;
  584. RASIPADDR ipaddrWins;
  585. RASIPADDR ipaddrWinsAlt;
  586. //
  587. // Framing
  588. //
  589. DWORD dwFrameSize;
  590. DWORD dwfNetProtocols;
  591. DWORD dwFramingProtocol;
  592. //
  593. // Scripting
  594. //
  595. WCHAR szScript[ MAX_PATH ];
  596. //
  597. // AutoDial
  598. //
  599. WCHAR szAutodialDll[ MAX_PATH ];
  600. WCHAR szAutodialFunc[ MAX_PATH ];
  601. //
  602. // Device
  603. //
  604. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  605. WCHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  606. //
  607. // X.25
  608. //
  609. WCHAR szX25PadType[ RAS_MaxPadType + 1 ];
  610. WCHAR szX25Address[ RAS_MaxX25Address + 1 ];
  611. WCHAR szX25Facilities[ RAS_MaxFacilities + 1 ];
  612. WCHAR szX25UserData[ RAS_MaxUserData + 1 ];
  613. DWORD dwChannels;
  614. //
  615. // Reserved
  616. //
  617. DWORD dwReserved1;
  618. DWORD dwReserved2;
  619. #if (WINVER >= 0x401)
  620. //
  621. // Multilink
  622. //
  623. DWORD dwSubEntries;
  624. DWORD dwDialMode;
  625. DWORD dwDialExtraPercent;
  626. DWORD dwDialExtraSampleSeconds;
  627. DWORD dwHangUpExtraPercent;
  628. DWORD dwHangUpExtraSampleSeconds;
  629. //
  630. // Idle timeout
  631. //
  632. DWORD dwIdleDisconnectSeconds;
  633. #endif
  634. #if (WINVER >= 0x500)
  635. //
  636. // Entry Type
  637. //
  638. DWORD dwType;
  639. //
  640. // EncryptionType
  641. //
  642. DWORD dwEncryptionType;
  643. //
  644. // CustomAuthKey to be used for EAP
  645. //
  646. DWORD dwCustomAuthKey;
  647. //
  648. // Guid of the connection
  649. //
  650. GUID guidId;
  651. //
  652. // Custom Dial Dll
  653. //
  654. WCHAR szCustomDialDll[MAX_PATH];
  655. //
  656. // Vpn Strategy
  657. //
  658. DWORD dwVpnStrategy;
  659. #endif
  660. };
  661. // RasSubEntry (<= v401)
  662. #define RASSUBENTRYA_V401 struct tagRASSUBENTRYA_V401
  663. RASSUBENTRYA_V401
  664. {
  665. DWORD dwSize;
  666. DWORD dwfFlags;
  667. //
  668. // Device
  669. //
  670. CHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  671. CHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  672. //
  673. // Phone numbers
  674. //
  675. CHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  676. DWORD dwAlternateOffset;
  677. };
  678. #define RASSUBENTRYW_V401 struct tagRASSUBENTRYW_V401
  679. RASSUBENTRYW_V401
  680. {
  681. DWORD dwSize;
  682. DWORD dwfFlags;
  683. //
  684. // Device
  685. //
  686. WCHAR szDeviceType[ RAS_MaxDeviceType + 1 ];
  687. WCHAR szDeviceName[ RAS_MaxDeviceName + 1 ];
  688. //
  689. // Phone numbers
  690. //
  691. WCHAR szLocalPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  692. DWORD dwAlternateOffset;
  693. };
  694. /* RAS structures as they appeared in NT 3.5 prior to 3.51 additions.
  695. */
  696. /* Windows NT 3.5 definitions.
  697. */
  698. /* Describes the results of a PPP IP (Internet) projection.
  699. */
  700. #define RASPPPIPW_V35 struct tagRASPPPIPW_V35
  701. RASPPPIPW_V35
  702. {
  703. DWORD dwSize;
  704. DWORD dwError;
  705. WCHAR szIpAddress[ RAS_MaxIpAddress + 1 ];
  706. };
  707. #define RASPPPIPA_V35 struct tagRASPPPIPA_V35
  708. RASPPPIPA_V35
  709. {
  710. DWORD dwSize;
  711. DWORD dwError;
  712. CHAR szIpAddress[ RAS_MaxIpAddress + 1 ];
  713. };
  714. /* Describes the results of a PPP IP (Internet) projection.
  715. */
  716. #define RASPPPIPW_V401 struct tagRASPPPIPW_V401
  717. RASPPPIPW_V401
  718. {
  719. DWORD dwSize;
  720. DWORD dwError;
  721. WCHAR szIpAddress[ RAS_MaxIpAddress + 1 ];
  722. #ifndef WINNT35COMPATIBLE
  723. WCHAR szServerIpAddress[ RAS_MaxIpAddress + 1 ];
  724. #endif
  725. };
  726. #define RASPPPIPA_V401 struct tagRASPPPIPA_V401
  727. RASPPPIPA_V401
  728. {
  729. DWORD dwSize;
  730. DWORD dwError;
  731. CHAR szIpAddress[ RAS_MaxIpAddress + 1 ];
  732. #ifndef WINNT35COMPATIBLE
  733. CHAR szServerIpAddress[ RAS_MaxIpAddress + 1 ];
  734. #endif
  735. };
  736. /* Describes the results of a PPP LCP/multi-link negotiation.
  737. */
  738. #define RASPPPLCP_V401 struct tagRASPPPLCP_V401
  739. RASPPPLCP_V401
  740. {
  741. DWORD dwSize;
  742. BOOL fBundled;
  743. };
  744. #define LPRASPPPLCP RASPPPLCP*
  745. /* Putting this here for backward compatibility with RASDIALPARAMS
  746. * structure as defined in FE version of nt 3.5
  747. */
  748. #define RASDIALPARAMSA_WINNT35J struct tagRASDIALPARAMSA_WINNT35J
  749. RASDIALPARAMSA_WINNT35J
  750. {
  751. DWORD dwSize;
  752. /* MSKK HitoshiT modified to supprot DBCS 94/9/2 */
  753. CHAR szEntryName[ RAS_MaxEntryName_V351 * sizeof( USHORT ) + 1 ];
  754. CHAR szPhoneNumber[ RAS_MaxPhoneNumber + 1 ];
  755. CHAR szCallbackNumber[ RAS_MaxCallbackNumber_V351 + 1 ];
  756. CHAR szUserName[ UNLEN + 1 ];
  757. CHAR szPassword[ PWLEN + 1 ];
  758. CHAR szDomain[ DNLEN * sizeof( USHORT ) + 1 ];
  759. };
  760. /* Describes extended connection establishment options. (See RasDial)
  761. */
  762. #define RASDIALEXTENSIONS_401 struct tagRASDIALEXTENSIONS_401
  763. RASDIALEXTENSIONS_401
  764. {
  765. DWORD dwSize;
  766. DWORD dwfOptions;
  767. HWND hwndParent;
  768. ULONG_PTR reserved;
  769. };
  770. #include "poppack.h"
  771. #endif /*_RASP_H_*/