paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2026-01-12 02:01:50 +01:00
Code Issues Packages Projects Releases Wiki Activity
762e335da1
fpc/packages/extra/winunits/jwanspapi.pas
fpc 790a4fe2d3 * log and id tags removed 
git-svn-id: trunk@42 -
2005-05-21 09:42:41 +00:00

1204 lines
34 KiB
ObjectPascal
Raw Blame History

{******************************************************************************}
{ }
{ Winsock2 Namespace API interface Unit for Object Pascal }
{ }
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
{ Corporation. All Rights Reserved. }
{ }
{ The original file is: nspapi.h, released June 2000. The original Pascal }
{ code is: NspApi.pas, released December 2000. The initial developer of the }
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl). }
{ }
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
{ Marcel van Brakel. All Rights Reserved. }
{ }
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
{ }
{ You may retrieve the latest version of this file at the Project JEDI }
{ APILIB home page, located at http://jedi-apilib.sourceforge.net }
{ }
{ The contents of this file are used with permission, subject to the Mozilla }
{ Public License Version 1.1 (the "License"); you may not use this file except }
{ in compliance with the License. You may obtain a copy of the License at }
{ http://www.mozilla.org/MPL/MPL-1.1.html }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, }
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
{ the specific language governing rights and limitations under the License. }
{ }
{ Alternatively, the contents of this file may be used under the terms of the }
{ GNU Lesser General Public License (the "LGPL License"), in which case the }
{ provisions of the LGPL License are applicable instead of those above. }
{ If you wish to allow use of your version of this file only under the terms }
{ of the LGPL License and not to allow others to use your version of this file }
{ under the MPL, indicate your decision by deleting the provisions above and }
{ replace them with the notice and other provisions required by the LGPL }
{ License. If you do not delete the provisions above, a recipient may use }
{ your version of this file under either the MPL or the LGPL License. }
{ }
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
{ }
{******************************************************************************}
unit JwaNspAPI;
{$WEAKPACKAGEUNIT}
{$HPPEMIT ''}
{$HPPEMIT '#include "nspapi.h"'}
{$HPPEMIT ''}
{$I jediapilib.inc}
interface
uses
JwaWinType, JwaWinSock2;
//
// Service categories
//
const
SERVICE_RESOURCE = $00000001;
{$EXTERNALSYM SERVICE_RESOURCE}
SERVICE_SERVICE = $00000002;
{$EXTERNALSYM SERVICE_SERVICE}
SERVICE_LOCAL = $00000004;
{$EXTERNALSYM SERVICE_LOCAL}
//
// Operation used when calling SetService()
//
SERVICE_REGISTER = $00000001;
{$EXTERNALSYM SERVICE_REGISTER}
SERVICE_DEREGISTER = $00000002;
{$EXTERNALSYM SERVICE_DEREGISTER}
SERVICE_FLUSH = $00000003;
{$EXTERNALSYM SERVICE_FLUSH}
SERVICE_ADD_TYPE = $00000004;
{$EXTERNALSYM SERVICE_ADD_TYPE}
SERVICE_DELETE_TYPE = $00000005;
{$EXTERNALSYM SERVICE_DELETE_TYPE}
//
// Flags that affect the operations above
//
SERVICE_FLAG_DEFER = $00000001;
{$EXTERNALSYM SERVICE_FLAG_DEFER}
SERVICE_FLAG_HARD = $00000002;
{$EXTERNALSYM SERVICE_FLAG_HARD}
//
// Used as input to GetService() for setting the dwProps parameter
//
PROP_COMMENT = $00000001;
{$EXTERNALSYM PROP_COMMENT}
PROP_LOCALE = $00000002;
{$EXTERNALSYM PROP_LOCALE}
PROP_DISPLAY_HINT = $00000004;
{$EXTERNALSYM PROP_DISPLAY_HINT}
PROP_VERSION = $00000008;
{$EXTERNALSYM PROP_VERSION}
PROP_START_TIME = $00000010;
{$EXTERNALSYM PROP_START_TIME}
PROP_MACHINE = $00000020;
{$EXTERNALSYM PROP_MACHINE}
PROP_ADDRESSES = $00000100;
{$EXTERNALSYM PROP_ADDRESSES}
PROP_SD = $00000200;
{$EXTERNALSYM PROP_SD}
PROP_ALL = DWORD($80000000);
{$EXTERNALSYM PROP_ALL}
//
// Flags that describe attributes of Service Addresses
//
SERVICE_ADDRESS_FLAG_RPC_CN = $00000001;
{$EXTERNALSYM SERVICE_ADDRESS_FLAG_RPC_CN}
SERVICE_ADDRESS_FLAG_RPC_DG = $00000002;
{$EXTERNALSYM SERVICE_ADDRESS_FLAG_RPC_DG}
SERVICE_ADDRESS_FLAG_RPC_NB = $00000004;
{$EXTERNALSYM SERVICE_ADDRESS_FLAG_RPC_NB}
//
// Name Spaces
//
NS_DEFAULT = 0;
{$EXTERNALSYM NS_DEFAULT}
NS_SAP = 1;
{$EXTERNALSYM NS_SAP}
NS_NDS = 2;
{$EXTERNALSYM NS_NDS}
NS_PEER_BROWSE = 3;
{$EXTERNALSYM NS_PEER_BROWSE}
NS_TCPIP_LOCAL = 10;
{$EXTERNALSYM NS_TCPIP_LOCAL}
NS_TCPIP_HOSTS = 11;
{$EXTERNALSYM NS_TCPIP_HOSTS}
NS_DNS = 12;
{$EXTERNALSYM NS_DNS}
NS_NETBT = 13;
{$EXTERNALSYM NS_NETBT}
NS_WINS = 14;
{$EXTERNALSYM NS_WINS}
NS_NBP = 20;
{$EXTERNALSYM NS_NBP}
NS_MS = 30;
{$EXTERNALSYM NS_MS}
NS_STDA = 31;
{$EXTERNALSYM NS_STDA}
NS_NTDS = 32;
{$EXTERNALSYM NS_NTDS}
NS_X500 = 40;
{$EXTERNALSYM NS_X500}
NS_NIS = 41;
{$EXTERNALSYM NS_NIS}
NS_VNS = 50;
{$EXTERNALSYM NS_VNS}
//
// Name space attributes.
//
NSTYPE_HIERARCHICAL = $00000001;
{$EXTERNALSYM NSTYPE_HIERARCHICAL}
NSTYPE_DYNAMIC = $00000002;
{$EXTERNALSYM NSTYPE_DYNAMIC}
NSTYPE_ENUMERABLE = $00000004;
{$EXTERNALSYM NSTYPE_ENUMERABLE}
NSTYPE_WORKGROUP = $00000008;
{$EXTERNALSYM NSTYPE_WORKGROUP}
//
// Transport attributes.
//
XP_CONNECTIONLESS = $00000001;
{$EXTERNALSYM XP_CONNECTIONLESS}
XP_GUARANTEED_DELIVERY = $00000002;
{$EXTERNALSYM XP_GUARANTEED_DELIVERY}
XP_GUARANTEED_ORDER = $00000004;
{$EXTERNALSYM XP_GUARANTEED_ORDER}
XP_MESSAGE_ORIENTED = $00000008;
{$EXTERNALSYM XP_MESSAGE_ORIENTED}
XP_PSEUDO_STREAM = $00000010;
{$EXTERNALSYM XP_PSEUDO_STREAM}
XP_GRACEFUL_CLOSE = $00000020;
{$EXTERNALSYM XP_GRACEFUL_CLOSE}
XP_EXPEDITED_DATA = $00000040;
{$EXTERNALSYM XP_EXPEDITED_DATA}
XP_CONNECT_DATA = $00000080;
{$EXTERNALSYM XP_CONNECT_DATA}
XP_DISCONNECT_DATA = $00000100;
{$EXTERNALSYM XP_DISCONNECT_DATA}
XP_SUPPORTS_BROADCAST = $00000200;
{$EXTERNALSYM XP_SUPPORTS_BROADCAST}
XP_SUPPORTS_MULTICAST = $00000400;
{$EXTERNALSYM XP_SUPPORTS_MULTICAST}
XP_BANDWIDTH_ALLOCATION = $00000800;
{$EXTERNALSYM XP_BANDWIDTH_ALLOCATION}
XP_FRAGMENTATION = $00001000;
{$EXTERNALSYM XP_FRAGMENTATION}
XP_ENCRYPTS = $00002000;
{$EXTERNALSYM XP_ENCRYPTS}
//
// Resolution flags for GetAddressByName().
//
RES_SOFT_SEARCH = $00000001;
{$EXTERNALSYM RES_SOFT_SEARCH}
RES_FIND_MULTIPLE = $00000002;
{$EXTERNALSYM RES_FIND_MULTIPLE}
RES_SERVICE = $00000004;
{$EXTERNALSYM RES_SERVICE}
//
// Well known value names for Service Types
//
SERVICE_TYPE_VALUE_SAPIDA = 'SapId';
{$EXTERNALSYM SERVICE_TYPE_VALUE_SAPIDA}
SERVICE_TYPE_VALUE_SAPIDW = WideString('SapId');
{$EXTERNALSYM SERVICE_TYPE_VALUE_SAPIDW}
SERVICE_TYPE_VALUE_CONNA = 'ConnectionOriented';
{$EXTERNALSYM SERVICE_TYPE_VALUE_CONNA}
SERVICE_TYPE_VALUE_CONNW = WideString('ConnectionOriented');
{$EXTERNALSYM SERVICE_TYPE_VALUE_CONNW}
SERVICE_TYPE_VALUE_TCPPORTA = 'TcpPort';
{$EXTERNALSYM SERVICE_TYPE_VALUE_TCPPORTA}
SERVICE_TYPE_VALUE_TCPPORTW = WideString('TcpPort');
{$EXTERNALSYM SERVICE_TYPE_VALUE_TCPPORTW}
SERVICE_TYPE_VALUE_UDPPORTA = 'UdpPort';
{$EXTERNALSYM SERVICE_TYPE_VALUE_UDPPORTA}
SERVICE_TYPE_VALUE_UDPPORTW = WideString('UdpPort');
{$EXTERNALSYM SERVICE_TYPE_VALUE_UDPPORTW}
{$IFDEF UNICODE}
SERVICE_TYPE_VALUE_SAPID = SERVICE_TYPE_VALUE_SAPIDW;
{$EXTERNALSYM SERVICE_TYPE_VALUE_SAPID}
SERVICE_TYPE_VALUE_CONN = SERVICE_TYPE_VALUE_CONNW;
{$EXTERNALSYM SERVICE_TYPE_VALUE_CONN}
SERVICE_TYPE_VALUE_TCPPORT = SERVICE_TYPE_VALUE_TCPPORTW;
{$EXTERNALSYM SERVICE_TYPE_VALUE_TCPPORT}
SERVICE_TYPE_VALUE_UDPPORT = SERVICE_TYPE_VALUE_UDPPORTW;
{$EXTERNALSYM SERVICE_TYPE_VALUE_UDPPORT}
{$ELSE}
SERVICE_TYPE_VALUE_SAPID = SERVICE_TYPE_VALUE_SAPIDA;
{$EXTERNALSYM SERVICE_TYPE_VALUE_SAPID}
SERVICE_TYPE_VALUE_CONN = SERVICE_TYPE_VALUE_CONNA;
{$EXTERNALSYM SERVICE_TYPE_VALUE_CONN}
SERVICE_TYPE_VALUE_TCPPORT = SERVICE_TYPE_VALUE_TCPPORTA;
{$EXTERNALSYM SERVICE_TYPE_VALUE_TCPPORT}
SERVICE_TYPE_VALUE_UDPPORT = SERVICE_TYPE_VALUE_UDPPORTA;
{$EXTERNALSYM SERVICE_TYPE_VALUE_UDPPORT}
{$ENDIF UNICODE}
//
// status flags returned by SetService
//
SET_SERVICE_PARTIAL_SUCCESS = $00000001;
{$EXTERNALSYM SET_SERVICE_PARTIAL_SUCCESS}
//
// Name Space Information
//
type
_NS_INFOA = record
dwNameSpace: DWORD;
dwNameSpaceFlags: DWORD;
lpNameSpace: LPSTR;
end;
{$EXTERNALSYM _NS_INFOA}
NS_INFOA = _NS_INFOA;
{$EXTERNALSYM NS_INFOA}
PNS_INFOA = ^NS_INFOA;
{$EXTERNALSYM PNS_INFOA}
LPNS_INFOA = ^NS_INFOA;
{$EXTERNALSYM LPNS_INFOA}
TNsInfoA = NS_INFOA;
PNsInfoA = LPNS_INFOA;
//
// Name Space Information
//
_NS_INFOW = record
dwNameSpace: DWORD;
dwNameSpaceFlags: DWORD;
lpNameSpace: LPWSTR;
end;
{$EXTERNALSYM _NS_INFOW}
NS_INFOW = _NS_INFOW;
{$EXTERNALSYM NS_INFOW}
PNS_INFOW = ^NS_INFOW;
{$EXTERNALSYM PNS_INFOW}
LPNS_INFOW = ^NS_INFOW;
{$EXTERNALSYM LPNS_INFOW}
TNsInfoW = NS_INFOW;
PNsInfoW = LPNS_INFOW;
{$IFDEF UNICODE}
NS_INFO = NS_INFOW;
{$EXTERNALSYM NS_INFO}
PNS_INFO = PNS_INFOW;
{$EXTERNALSYM PNS_INFO}
LPNS_INFO = LPNS_INFOW;
{$EXTERNALSYM LPNS_INFO}
TNsInfo = TNsInfoW;
PNsInfo = PNsInfoW;
{$ELSE}
NS_INFO = NS_INFOA;
{$EXTERNALSYM NS_INFO}
PNS_INFO = PNS_INFOA;
{$EXTERNALSYM PNS_INFO}
LPNS_INFO = LPNS_INFOA;
{$EXTERNALSYM LPNS_INFO}
TNsInfo = TNsInfoA;
PNsInfo = PNsInfoA;
{$ENDIF UNICODE}
//
// Service Type Values. The structures are used to define named Service
// Type specific values. This structure is self relative and has no pointers.
//
LPSERVICE_TYPE_VALUE = ^SERVICE_TYPE_VALUE;
{$EXTERNALSYM LPSERVICE_TYPE_VALUE}
PSERVICE_TYPE_VALUE = ^SERVICE_TYPE_VALUE;
{$EXTERNALSYM PSERVICE_TYPE_VALUE}
_SERVICE_TYPE_VALUE = record
dwNameSpace: DWORD;
dwValueType: DWORD;
dwValueSize: DWORD;
dwValueNameOffset: DWORD;
dwValueOffset: DWORD;
end;
{$EXTERNALSYM _SERVICE_TYPE_VALUE}
SERVICE_TYPE_VALUE = _SERVICE_TYPE_VALUE;
{$EXTERNALSYM SERVICE_TYPE_VALUE}
TServiceTypeValue = SERVICE_TYPE_VALUE;
PServiceTypeValue = LPSERVICE_TYPE_VALUE;
//
// An absolute version of above. This structure does contain pointers.
//
LPSERVICE_TYPE_VALUE_ABSA = ^SERVICE_TYPE_VALUE_ABSA;
{$EXTERNALSYM LPSERVICE_TYPE_VALUE_ABSA}
PSERVICE_TYPE_VALUE_ABSA = ^SERVICE_TYPE_VALUE_ABSA;
{$EXTERNALSYM PSERVICE_TYPE_VALUE_ABSA}
_SERVICE_TYPE_VALUE_ABSA = record
dwNameSpace: DWORD;
dwValueType: DWORD;
dwValueSize: DWORD;
lpValueName: LPSTR;
lpValue: LPVOID;
end;
{$EXTERNALSYM _SERVICE_TYPE_VALUE_ABSA}
SERVICE_TYPE_VALUE_ABSA = _SERVICE_TYPE_VALUE_ABSA;
{$EXTERNALSYM SERVICE_TYPE_VALUE_ABSA}
TServiceTypeValueAbsA = SERVICE_TYPE_VALUE_ABSA;
PServiceTypeValueAbsA = LPSERVICE_TYPE_VALUE_ABSA;
//
// An absolute version of above. This structure does contain pointers.
//
LPSERVICE_TYPE_VALUE_ABSW = ^SERVICE_TYPE_VALUE_ABSW;
{$EXTERNALSYM LPSERVICE_TYPE_VALUE_ABSW}
PSERVICE_TYPE_VALUE_ABSW = ^SERVICE_TYPE_VALUE_ABSW;
{$EXTERNALSYM PSERVICE_TYPE_VALUE_ABSW}
_SERVICE_TYPE_VALUE_ABSW = record
dwNameSpace: DWORD;
dwValueType: DWORD;
dwValueSize: DWORD;
lpValueName: LPWSTR;
lpValue: LPVOID;
end;
{$EXTERNALSYM _SERVICE_TYPE_VALUE_ABSW}
SERVICE_TYPE_VALUE_ABSW = _SERVICE_TYPE_VALUE_ABSW;
{$EXTERNALSYM SERVICE_TYPE_VALUE_ABSW}
TServiceTypeValueAbsW = SERVICE_TYPE_VALUE_ABSW;
PServiceTypeValueAbsW = LPSERVICE_TYPE_VALUE_ABSW;
{$IFDEF UNICODE}
SERVICE_TYPE_VALUE_ABS = SERVICE_TYPE_VALUE_ABSW;
{$EXTERNALSYM SERVICE_TYPE_VALUE_ABS}
PSERVICE_TYPE_VALUE_ABS = PSERVICE_TYPE_VALUE_ABSW;
{$EXTERNALSYM PSERVICE_TYPE_VALUE_ABS}
LPSERVICE_TYPE_VALUE_ABS = LPSERVICE_TYPE_VALUE_ABSW;
{$EXTERNALSYM LPSERVICE_TYPE_VALUE_ABS}
TServiceTypeValueAbs = TServiceTypeValueAbsW;
PServiceTypeValueAbs = PServiceTypeValueAbsW;
{$ELSE}
SERVICE_TYPE_VALUE_ABS = SERVICE_TYPE_VALUE_ABSA;
{$EXTERNALSYM SERVICE_TYPE_VALUE_ABS}
PSERVICE_TYPE_VALUE_ABS = PSERVICE_TYPE_VALUE_ABSA;
{$EXTERNALSYM PSERVICE_TYPE_VALUE_ABS}
LPSERVICE_TYPE_VALUE_ABS = LPSERVICE_TYPE_VALUE_ABSA;
{$EXTERNALSYM LPSERVICE_TYPE_VALUE_ABS}
TServiceTypeValueAbs = TServiceTypeValueAbsA;
PServiceTypeValueAbs = PServiceTypeValueAbsA;
{$ENDIF UNICODE}
//
// Service Type Information. Contains the name of the Service Type and
// and an array of SERVICE_NS_TYPE_VALUE structures. This structure is self
// relative and has no pointers in it.
//
LPSERVICE_TYPE_INFO = ^SERVICE_TYPE_INFO;
{$EXTERNALSYM LPSERVICE_TYPE_INFO}
PSERVICE_TYPE_INFO = ^SERVICE_TYPE_INFO;
{$EXTERNALSYM PSERVICE_TYPE_INFO}
_SERVICE_TYPE_INFO = record
dwTypeNameOffset: DWORD;
dwValueCount: DWORD;
Values: array [0..0] of SERVICE_TYPE_VALUE;
end;
{$EXTERNALSYM _SERVICE_TYPE_INFO}
SERVICE_TYPE_INFO = _SERVICE_TYPE_INFO;
{$EXTERNALSYM SERVICE_TYPE_INFO}
TServiceTypeInfo = SERVICE_TYPE_INFO;
PServiceTypeInfo = LPSERVICE_TYPE_INFO;
LPSERVICE_TYPE_INFO_ABSA = ^SERVICE_TYPE_INFO_ABSA;
{$EXTERNALSYM LPSERVICE_TYPE_INFO_ABSA}
PSERVICE_TYPE_INFO_ABSA = ^SERVICE_TYPE_INFO_ABSA;
{$EXTERNALSYM PSERVICE_TYPE_INFO_ABSA}
_SERVICE_TYPE_INFO_ABSA = record
lpTypeName: LPSTR;
dwValueCount: DWORD;
Values: array [0..0] of SERVICE_TYPE_VALUE_ABSA;
end;
{$EXTERNALSYM _SERVICE_TYPE_INFO_ABSA}
SERVICE_TYPE_INFO_ABSA = _SERVICE_TYPE_INFO_ABSA;
{$EXTERNALSYM SERVICE_TYPE_INFO_ABSA}
TServiceTypeInfoAbsA = SERVICE_TYPE_INFO_ABSA;
PServiceTypeInfoAbsA = PSERVICE_TYPE_INFO_ABSA;
LPSERVICE_TYPE_INFO_ABSW = ^SERVICE_TYPE_INFO_ABSW;
{$EXTERNALSYM LPSERVICE_TYPE_INFO_ABSW}
PSERVICE_TYPE_INFO_ABSW = ^SERVICE_TYPE_INFO_ABSW;
{$EXTERNALSYM PSERVICE_TYPE_INFO_ABSW}
_SERVICE_TYPE_INFO_ABSW = record
lpTypeName: LPWSTR;
dwValueCount: DWORD;
Values: array [0..0] of SERVICE_TYPE_VALUE_ABSW;
end;
{$EXTERNALSYM _SERVICE_TYPE_INFO_ABSW}
SERVICE_TYPE_INFO_ABSW = _SERVICE_TYPE_INFO_ABSW;
{$EXTERNALSYM SERVICE_TYPE_INFO_ABSW}
TServiceTypeInfoAbsW = SERVICE_TYPE_INFO_ABSW;
PServiceTypeInfoAbsW = LPSERVICE_TYPE_INFO_ABSW;
{$IFDEF UNICODE}
SERVICE_TYPE_INFO_ABS = SERVICE_TYPE_INFO_ABSW;
{$EXTERNALSYM SERVICE_TYPE_INFO_ABS}
PSERVICE_TYPE_INFO_ABS = PSERVICE_TYPE_INFO_ABSW;
{$EXTERNALSYM PSERVICE_TYPE_INFO_ABS}
LPSERVICE_TYPE_INFO_ABS = LPSERVICE_TYPE_INFO_ABSW;
{$EXTERNALSYM LPSERVICE_TYPE_INFO_ABS}
TServiceTypeInfoAbs = TServiceTypeInfoAbsW;
PServiceTypeInfoAbs = PServiceTypeInfoAbsW;
{$ELSE}
SERVICE_TYPE_INFO_ABS = SERVICE_TYPE_INFO_ABSA;
{$EXTERNALSYM SERVICE_TYPE_INFO_ABS}
PSERVICE_TYPE_INFO_ABS = PSERVICE_TYPE_INFO_ABSA;
{$EXTERNALSYM PSERVICE_TYPE_INFO_ABS}
LPSERVICE_TYPE_INFO_ABS = LPSERVICE_TYPE_INFO_ABSA;
{$EXTERNALSYM LPSERVICE_TYPE_INFO_ABS}
TServiceTypeInfoAbs = TServiceTypeInfoAbsA;
PServiceTypeInfoAbs = PServiceTypeInfoAbsA;
{$ENDIF UNICODE}
//
// A Single Address definition.
//
LPSERVICE_ADDRESS = ^SERVICE_ADDRESS;
{$EXTERNALSYM LPSERVICE_ADDRESS}
PSERVICE_ADDRESS = ^SERVICE_ADDRESS;
{$EXTERNALSYM PSERVICE_ADDRESS}
_SERVICE_ADDRESS = record
dwAddressType: DWORD;
dwAddressFlags: DWORD;
dwAddressLength: DWORD;
dwPrincipalLength: DWORD;
lpAddress: LPBYTE;
lpPrincipal: LPBYTE;
end;
{$EXTERNALSYM _SERVICE_ADDRESS}
SERVICE_ADDRESS = _SERVICE_ADDRESS;
{$EXTERNALSYM SERVICE_ADDRESS}
TServiceAddress = SERVICE_ADDRESS;
PServiceAddress = LPSERVICE_ADDRESS;
//
// Addresses used by the service. Contains array of SERVICE_ADDRESS.
//
LPSERVICE_ADDRESSES = ^SERVICE_ADDRESSES;
{$EXTERNALSYM LPSERVICE_ADDRESSES}
PSERVICE_ADDRESSES = ^SERVICE_ADDRESSES;
{$EXTERNALSYM PSERVICE_ADDRESSES}
_SERVICE_ADDRESSES = record
dwAddressCount: DWORD;
Addresses: array [0..0] of SERVICE_ADDRESS;
end;
{$EXTERNALSYM _SERVICE_ADDRESSES}
SERVICE_ADDRESSES = _SERVICE_ADDRESSES;
{$EXTERNALSYM SERVICE_ADDRESSES}
TServiceAddresses = SERVICE_ADDRESSES;
PServiceAddresses = PSERVICE_ADDRESSES;
//
// Service Information.
//
LPSERVICE_INFOA = ^SERVICE_INFOA;
{$EXTERNALSYM LPSERVICE_INFOA}
PSERVICE_INFOA = ^SERVICE_INFOA;
{$EXTERNALSYM PSERVICE_INFOA}
_SERVICE_INFOA = record
lpServiceType: PGUID;
lpServiceName: LPSTR;
lpComment: LPSTR;
lpLocale: LPSTR;
dwDisplayHint: DWORD;
dwVersion: DWORD;
dwTime: DWORD;
lpMachineName: LPSTR;
lpServiceAddress: LPSERVICE_ADDRESSES;
ServiceSpecificInfo: BLOB;
end;
{$EXTERNALSYM _SERVICE_INFOA}
SERVICE_INFOA = _SERVICE_INFOA;
{$EXTERNALSYM SERVICE_INFOA}
TServiceInfoA = SERVICE_INFOA;
PServiceInfoA = PSERVICE_INFOA;
//
// Service Information.
//
LPSERVICE_INFOW = ^SERVICE_INFOW;
{$EXTERNALSYM LPSERVICE_INFOW}
PSERVICE_INFOW = ^SERVICE_INFOW;
{$EXTERNALSYM PSERVICE_INFOW}
_SERVICE_INFOW = record
lpServiceType: PGUID;
lpServiceName: LPWSTR;
lpComment: LPWSTR;
lpLocale: LPWSTR;
dwDisplayHint: DWORD;
dwVersion: DWORD;
dwTime: DWORD;
lpMachineName: LPWSTR;
lpServiceAddress: LPSERVICE_ADDRESSES;
ServiceSpecificInfo: BLOB;
end;
{$EXTERNALSYM _SERVICE_INFOW}
SERVICE_INFOW = _SERVICE_INFOW;
{$EXTERNALSYM SERVICE_INFOW}
TServiceInfoW = SERVICE_INFOW;
PServiceInfoW = PSERVICE_INFOW;
{$IFDEF UNICODE}
SERVICE_INFO = SERVICE_INFOW;
{$EXTERNALSYM SERVICE_INFO}
PSERVICE_INFO = PSERVICE_INFOW;
{$EXTERNALSYM PSERVICE_INFO}
LPSERVICE_INFO = LPSERVICE_INFOW;
{$EXTERNALSYM LPSERVICE_INFO}
TServiceInfo = TServiceInfoW;
PServiceInfo = PServiceInfoW;
{$ELSE}
SERVICE_INFO = SERVICE_INFOA;
{$EXTERNALSYM SERVICE_INFO}
PSERVICE_INFO = PSERVICE_INFOA;
{$EXTERNALSYM PSERVICE_INFO}
LPSERVICE_INFO = LPSERVICE_INFOA;
{$EXTERNALSYM LPSERVICE_INFO}
TServiceInfo = TServiceInfoA;
PServiceInfo = PServiceInfoA;
{$ENDIF UNICODE}
//
// Name Space & Service Information
//
LPNS_SERVICE_INFOA = ^NS_SERVICE_INFOA;
{$EXTERNALSYM LPNS_SERVICE_INFOA}
PNS_SERVICE_INFOA = ^NS_SERVICE_INFOA;
{$EXTERNALSYM PNS_SERVICE_INFOA}
_NS_SERVICE_INFOA = record
dwNameSpace: DWORD;
ServiceInfo: SERVICE_INFOA;
end;
{$EXTERNALSYM _NS_SERVICE_INFOA}
NS_SERVICE_INFOA = _NS_SERVICE_INFOA;
{$EXTERNALSYM NS_SERVICE_INFOA}
TNsServiceInfoA = NS_SERVICE_INFOA;
PNsServiceInfoA = LPNS_SERVICE_INFOA;
//
// Name Space & Service Information
//
LPNS_SERVICE_INFOW = ^NS_SERVICE_INFOW;
{$EXTERNALSYM LPNS_SERVICE_INFOW}
PNS_SERVICE_INFOW = ^NS_SERVICE_INFOW;
{$EXTERNALSYM PNS_SERVICE_INFOW}
_NS_SERVICE_INFOW = record
dwNameSpace: DWORD;
ServiceInfo: SERVICE_INFOW;
end;
{$EXTERNALSYM _NS_SERVICE_INFOW}
NS_SERVICE_INFOW = _NS_SERVICE_INFOW;
{$EXTERNALSYM NS_SERVICE_INFOW}
TNsServiceInfoW = NS_SERVICE_INFOW;
PNsServiceInfoW = LPNS_SERVICE_INFOW;
{$IFDEF UNICODE}
NS_SERVICE_INFO = NS_SERVICE_INFOW;
{$EXTERNALSYM NS_SERVICE_INFO}
PNS_SERVICE_INFO = PNS_SERVICE_INFOW;
{$EXTERNALSYM PNS_SERVICE_INFO}
LPNS_SERVICE_INFO = LPNS_SERVICE_INFOW;
{$EXTERNALSYM LPNS_SERVICE_INFO}
TNsServiceInfo = TNsServiceInfoW;
PNsServiceInfo = PNsServiceInfoW;
{$ELSE}
NS_SERVICE_INFO = NS_SERVICE_INFOA;
{$EXTERNALSYM NS_SERVICE_INFO}
PNS_SERVICE_INFO = PNS_SERVICE_INFOA;
{$EXTERNALSYM PNS_SERVICE_INFO}
LPNS_SERVICE_INFO = LPNS_SERVICE_INFOA;
{$EXTERNALSYM LPNS_SERVICE_INFO}
TNsServiceInfo = TNsServiceInfoA;
PNsServiceInfo = PNsServiceInfoA;
{$ENDIF UNICODE}
//
// SockAddr Information
//
LPSOCKET_ADDRESS = ^SOCKET_ADDRESS;
{$EXTERNALSYM LPSOCKET_ADDRESS}
PSOCKET_ADDRESS = ^SOCKET_ADDRESS;
{$EXTERNALSYM PSOCKET_ADDRESS}
_SOCKET_ADDRESS = record
lpSockaddr: LPSOCKADDR;
iSockaddrLength: Integer;
end;
{$EXTERNALSYM _SOCKET_ADDRESS}
SOCKET_ADDRESS = _SOCKET_ADDRESS;
{$EXTERNALSYM SOCKET_ADDRESS}
TSocketAddress = SOCKET_ADDRESS;
PSocketAddress = PSOCKET_ADDRESS;
//
// CSAddr Information
//
LPCSADDR_INFO = ^CSADDR_INFO;
{$EXTERNALSYM LPCSADDR_INFO}
PCSADDR_INFO = ^CSADDR_INFO;
{$EXTERNALSYM PCSADDR_INFO}
_CSADDR_INFO = record
LocalAddr: SOCKET_ADDRESS;
RemoteAddr: SOCKET_ADDRESS;
iSocketType: Integer;
iProtocol: Integer;
end;
{$EXTERNALSYM _CSADDR_INFO}
CSADDR_INFO = _CSADDR_INFO;
{$EXTERNALSYM CSADDR_INFO}
TCsAddrInfo = CSADDR_INFO;
PCsAddrInfo = LPCSADDR_INFO;
//
// Protocol Information
//
LPPROTOCOL_INFOA = ^PROTOCOL_INFOA;
{$EXTERNALSYM LPPROTOCOL_INFOA}
PPROTOCOL_INFOA = ^PROTOCOL_INFOA;
{$EXTERNALSYM PPROTOCOL_INFOA}
_PROTOCOL_INFOA = record
dwServiceFlags: DWORD;
iAddressFamily: Integer;
iMaxSockAddr: Integer;
iMinSockAddr: Integer;
iSocketType: Integer;
iProtocol: Integer;
dwMessageSize: DWORD;
lpProtocol: LPSTR;
end;
{$EXTERNALSYM _PROTOCOL_INFOA}
PROTOCOL_INFOA = _PROTOCOL_INFOA;
{$EXTERNALSYM PROTOCOL_INFOA}
TProtocolInfoA = PROTOCOL_INFOA;
PProtocolInfoA = LPPROTOCOL_INFOA;
//
// Protocol Information
//
LPPROTOCOL_INFOW = ^PROTOCOL_INFOW;
{$EXTERNALSYM LPPROTOCOL_INFOW}
PPROTOCOL_INFOW = ^PROTOCOL_INFOW;
{$EXTERNALSYM PPROTOCOL_INFOW}
_PROTOCOL_INFOW = record
dwServiceFlags: DWORD;
iAddressFamily: Integer;
iMaxSockAddr: Integer;
iMinSockAddr: Integer;
iSocketType: Integer;
iProtocol: Integer;
dwMessageSize: DWORD;
lpProtocol: LPWSTR;
end;
{$EXTERNALSYM _PROTOCOL_INFOW}
PROTOCOL_INFOW = _PROTOCOL_INFOW;
{$EXTERNALSYM PROTOCOL_INFOW}
TProtocolInfoW = PROTOCOL_INFOW;
PProtocolInfoW = LPPROTOCOL_INFOW;
{$IFDEF UNICODE}
PROTOCOL_INFO = PROTOCOL_INFOW;
{$EXTERNALSYM PROTOCOL_INFO}
PPROTOCOL_INFO = PPROTOCOL_INFOW;
{$EXTERNALSYM PPROTOCOL_INFO}
LPPROTOCOL_INFO = LPPROTOCOL_INFOW;
{$EXTERNALSYM LPPROTOCOL_INFO}
TProtocolInfo = TProtocolInfoW;
PProtocolInfo = PProtocolInfoW;
{$ELSE}
PROTOCOL_INFO = PROTOCOL_INFOA;
{$EXTERNALSYM PROTOCOL_INFO}
PPROTOCOL_INFO = PPROTOCOL_INFOA;
{$EXTERNALSYM PPROTOCOL_INFO}
LPPROTOCOL_INFO = LPPROTOCOL_INFOA;
{$EXTERNALSYM LPPROTOCOL_INFO}
TProtocolInfo = TProtocolInfoA;
PProtocolInfo = PProtocolInfoA;
{$ENDIF UNICODE}
//
// NETRESOURCE2 Structure
//
LPNETRESOURCE2A = ^NETRESOURCE2A;
{$EXTERNALSYM LPNETRESOURCE2A}
PNETRESOURCE2A = ^NETRESOURCE2A;
{$EXTERNALSYM PNETRESOURCE2A}
_NETRESOURCE2A = record
dwScope: DWORD;
dwType: DWORD;
dwUsage: DWORD;
dwDisplayType: DWORD;
lpLocalName: LPSTR;
lpRemoteName: LPSTR;
lpComment: LPSTR;
ns_info: NS_INFO;
ServiceType: TGUID;
dwProtocols: DWORD;
lpiProtocols: PINT;
end;
{$EXTERNALSYM _NETRESOURCE2A}
NETRESOURCE2A = _NETRESOURCE2A;
{$EXTERNALSYM NETRESOURCE2A}
TNetResource2A = NETRESOURCE2A;
//
// NETRESOURCE2 Structure
//
LPNETRESOURCE2W = ^NETRESOURCE2W;
{$EXTERNALSYM LPNETRESOURCE2W}
PNETRESOURCE2W = ^NETRESOURCE2W;
{$EXTERNALSYM PNETRESOURCE2W}
_NETRESOURCE2W = record
dwScope: DWORD;
dwType: DWORD;
dwUsage: DWORD;
dwDisplayType: DWORD;
lpLocalName: LPWSTR;
lpRemoteName: LPWSTR;
lpComment: LPWSTR;
ns_info: NS_INFO;
ServiceType: TGUID;
dwProtocols: DWORD;
lpiProtocols: PINT;
end;
{$EXTERNALSYM _NETRESOURCE2W}
NETRESOURCE2W = _NETRESOURCE2W;
{$EXTERNALSYM NETRESOURCE2W}
TNetResource2W = NETRESOURCE2W;
{$IFDEF UNICODE}
NETRESOURCE2 = NETRESOURCE2W;
{$EXTERNALSYM NETRESOURCE2}
PNETRESOURCE2 = PNETRESOURCE2W;
{$EXTERNALSYM PNETRESOURCE2}
LPNETRESOURCE2 = LPNETRESOURCE2W;
{$EXTERNALSYM LPNETRESOURCE2}
TNetResource2 = TNetResource2W;
{$ELSE}
NETRESOURCE2 = NETRESOURCE2A;
{$EXTERNALSYM NETRESOURCE2}
PNETRESOURCE2 = PNETRESOURCE2A;
{$EXTERNALSYM PNETRESOURCE2}
LPNETRESOURCE2 = LPNETRESOURCE2A;
{$EXTERNALSYM LPNETRESOURCE2}
TNetResource2 = TNetResource2A;
{$ENDIF UNICODE}
LPFN_NSPAPI = function: DWORD; stdcall;
{$EXTERNALSYM LPFN_NSPAPI}
TFnNspApi = LPFN_NSPAPI;
//
// Structures for using the service routines asynchronously.
//
type
LPSERVICE_CALLBACK_PROC = procedure(lParam: LPARAM; hAsyncTaskHandle: HANDLE); stdcall;
{$EXTERNALSYM LPSERVICE_CALLBACK_PROC}
TServiceCallbackProc = LPSERVICE_CALLBACK_PROC;
type
LPSERVICE_ASYNC_INFO = ^SERVICE_ASYNC_INFO;
{$EXTERNALSYM LPSERVICE_ASYNC_INFO}
PSERVICE_ASYNC_INFO = ^SERVICE_ASYNC_INFO;
{$EXTERNALSYM PSERVICE_ASYNC_INFO}
_SERVICE_ASYNC_INFO = record
lpServiceCallbackProc: LPSERVICE_CALLBACK_PROC;
lParam: LPARAM;
hAsyncTaskHandle: HANDLE;
end;
{$EXTERNALSYM _SERVICE_ASYNC_INFO}
SERVICE_ASYNC_INFO = _SERVICE_ASYNC_INFO;
{$EXTERNALSYM SERVICE_ASYNC_INFO}
TServiceAsyncInfo = SERVICE_ASYNC_INFO;
PServiceAsyncInfo = LPSERVICE_ASYNC_INFO;
//
// Public NSP API prototypes.
//
function EnumProtocolsA(lpiProtocols: PINT; lpProtocolBuffer: LPVOID; lpdwBufferLength: LPDWORD): Integer; stdcall;
{$EXTERNALSYM EnumProtocolsA}
function EnumProtocolsW(lpiProtocols: PINT; lpProtocolBuffer: LPVOID; lpdwBufferLength: LPDWORD): Integer; stdcall;
{$EXTERNALSYM EnumProtocolsW}
function EnumProtocols(lpiProtocols: PINT; lpProtocolBuffer: LPVOID; lpdwBufferLength: LPDWORD): Integer; stdcall;
{$EXTERNALSYM EnumProtocols}
function GetAddressByNameA(dwNameSpace: DWORD; const lpServiceType: TGUID;
lpServiceName: LPSTR; lpiProtocols: PINT; dwResolution: DWORD;
lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO; lpCsaddrBuffer: LPVOID;
var lpdwBufferLength: DWORD; lpAliasBuffer: LPSTR; lpdwAliasBufferLength: LPDWORD): Integer; stdcall;
{$EXTERNALSYM GetAddressByNameA}
function GetAddressByNameW(dwNameSpace: DWORD; const lpServiceType: TGUID;
lpServiceName: LPWSTR; lpiProtocols: PINT; dwResolution: DWORD;
lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO; lpCsaddrBuffer: LPVOID;
var lpdwBufferLength: DWORD; lpAliasBuffer: LPWSTR; lpdwAliasBufferLength: LPDWORD): Integer; stdcall;
{$EXTERNALSYM GetAddressByNameW}
function GetAddressByName(dwNameSpace: DWORD; const lpServiceType: TGUID;
lpServiceName: LPTSTR; lpiProtocols: PINT; dwResolution: DWORD;
lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO; lpCsaddrBuffer: LPVOID;
var lpdwBufferLength: DWORD; lpAliasBuffer: LPTSTR; lpdwAliasBufferLength: LPDWORD): Integer; stdcall;
{$EXTERNALSYM GetAddressByName}
function GetTypeByNameA(lpServiceName: LPSTR; var lpServiceType: TGUID): Integer; stdcall;
{$EXTERNALSYM GetTypeByNameA}
function GetTypeByNameW(lpServiceName: LPWSTR; var lpServiceType: TGUID): Integer; stdcall;
{$EXTERNALSYM GetTypeByNameW}
function GetTypeByName(lpServiceName: LPTSTR; var lpServiceType: TGUID): Integer; stdcall;
{$EXTERNALSYM GetTypeByName}
function GetNameByTypeA(const lpServiceType: TGUID; lpServiceName: LPSTR; dwNameLength: DWORD): Integer; stdcall;
{$EXTERNALSYM GetNameByTypeA}
function GetNameByTypeW(const lpServiceType: TGUID; lpServiceName: LPWSTR; dwNameLength: DWORD): Integer; stdcall;
{$EXTERNALSYM GetNameByTypeW}
function GetNameByType(const lpServiceType: TGUID; lpServiceName: LPTSTR; dwNameLength: DWORD): Integer; stdcall;
{$EXTERNALSYM GetNameByType}
function SetServiceA(dwNameSpace, dwOperation, dwFlags: DWORD;
const lpServiceInfo: SERVICE_INFOA; lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO;
var lpdwStatusFlags: DWORD): Integer; stdcall;
{$EXTERNALSYM SetServiceA}
function SetServiceW(dwNameSpace, dwOperation, dwFlags: DWORD;
const lpServiceInfo: SERVICE_INFOW; lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO;
var lpdwStatusFlags: DWORD): Integer; stdcall;
{$EXTERNALSYM SetServiceW}
function SetService(dwNameSpace, dwOperation, dwFlags: DWORD;
const lpServiceInfo: SERVICE_INFO; lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO;
var lpdwStatusFlags: DWORD): Integer; stdcall;
{$EXTERNALSYM SetService}
function GetServiceA(dwNameSpace: DWORD; const lpGuid: TGUID; lpServiceName: LPSTR;
dwProperties: DWORD; lpBuffer: LPVOID; var lpdwBufferSize: DWORD;
lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO): Integer; stdcall;
{$EXTERNALSYM GetServiceA}
function GetServiceW(dwNameSpace: DWORD; const lpGuid: TGUID; lpServiceName: LPWSTR;
dwProperties: DWORD; lpBuffer: LPVOID; var lpdwBufferSize: DWORD;
lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO): Integer; stdcall;
{$EXTERNALSYM GetServiceW}
function GetService(dwNameSpace: DWORD; const lpGuid: TGUID; lpServiceName: LPTSTR;
dwProperties: DWORD; lpBuffer: LPVOID; var lpdwBufferSize: DWORD;
lpServiceAsyncInfo: LPSERVICE_ASYNC_INFO): Integer; stdcall;
{$EXTERNALSYM GetService}
implementation
const
nsplib = 'wsock32.dll';
{$IFDEF UNICODE}
AWSuffix = 'W';
{$ELSE}
AWSuffix = 'A';
{$ENDIF UNICODE}
{$IFDEF DYNAMIC_LINK}
var
_EnumProtocolsA: Pointer;
function EnumProtocolsA;
begin
GetProcedureAddress(_EnumProtocolsA, nsplib, 'EnumProtocolsA');
asm
MOV ESP, EBP
POP EBP
JMP [_EnumProtocolsA]
end;
end;
var
_EnumProtocolsW: Pointer;
function EnumProtocolsW;
begin
GetProcedureAddress(_EnumProtocolsW, nsplib, 'EnumProtocolsW');
asm
MOV ESP, EBP
POP EBP
JMP [_EnumProtocolsW]
end;
end;
var
_EnumProtocols: Pointer;
function EnumProtocols;
begin
GetProcedureAddress(_EnumProtocols, nsplib, 'EnumProtocols' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_EnumProtocols]
end;
end;
var
_GetAddressByNameA: Pointer;
function GetAddressByNameA;
begin
GetProcedureAddress(_GetAddressByNameA, nsplib, 'GetAddressByNameA');
asm
MOV ESP, EBP
POP EBP
JMP [_GetAddressByNameA]
end;
end;
var
_GetAddressByNameW: Pointer;
function GetAddressByNameW;
begin
GetProcedureAddress(_GetAddressByNameW, nsplib, 'GetAddressByNameW');
asm
MOV ESP, EBP
POP EBP
JMP [_GetAddressByNameW]
end;
end;
var
_GetAddressByName: Pointer;
function GetAddressByName;
begin
GetProcedureAddress(_GetAddressByName, nsplib, 'GetAddressByName' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_GetAddressByName]
end;
end;
var
_GetTypeByNameA: Pointer;
function GetTypeByNameA;
begin
GetProcedureAddress(_GetTypeByNameA, nsplib, 'GetTypeByNameA');
asm
MOV ESP, EBP
POP EBP
JMP [_GetTypeByNameA]
end;
end;
var
_GetTypeByNameW: Pointer;
function GetTypeByNameW;
begin
GetProcedureAddress(_GetTypeByNameW, nsplib, 'GetTypeByNameW');
asm
MOV ESP, EBP
POP EBP
JMP [_GetTypeByNameW]
end;
end;
var
_GetTypeByName: Pointer;
function GetTypeByName;
begin
GetProcedureAddress(_GetTypeByName, nsplib, 'GetTypeByName' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_GetTypeByName]
end;
end;
var
_GetNameByTypeA: Pointer;
function GetNameByTypeA;
begin
GetProcedureAddress(_GetNameByTypeA, nsplib, 'GetNameByTypeA');
asm
MOV ESP, EBP
POP EBP
JMP [_GetNameByTypeA]
end;
end;
var
_GetNameByTypeW: Pointer;
function GetNameByTypeW;
begin
GetProcedureAddress(_GetNameByTypeW, nsplib, 'GetNameByTypeW');
asm
MOV ESP, EBP
POP EBP
JMP [_GetNameByTypeW]
end;
end;
var
_GetNameByType: Pointer;
function GetNameByType;
begin
GetProcedureAddress(_GetNameByType, nsplib, 'GetNameByType' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_GetNameByType]
end;
end;
var
_SetServiceA: Pointer;
function SetServiceA;
begin
GetProcedureAddress(_SetServiceA, nsplib, 'SetServiceA');
asm
MOV ESP, EBP
POP EBP
JMP [_SetServiceA]
end;
end;
var
_SetServiceW: Pointer;
function SetServiceW;
begin
GetProcedureAddress(_SetServiceW, nsplib, 'SetServiceW');
asm
MOV ESP, EBP
POP EBP
JMP [_SetServiceW]
end;
end;
var
_SetService: Pointer;
function SetService;
begin
GetProcedureAddress(_SetService, nsplib, 'SetService' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_SetService]
end;
end;
var
_GetServiceA: Pointer;
function GetServiceA;
begin
GetProcedureAddress(_GetServiceA, nsplib, 'GetServiceA');
asm
MOV ESP, EBP
POP EBP
JMP [_GetServiceA]
end;
end;
var
_GetServiceW: Pointer;
function GetServiceW;
begin
GetProcedureAddress(_GetServiceW, nsplib, 'GetServiceW');
asm
MOV ESP, EBP
POP EBP
JMP [_GetServiceW]
end;
end;
var
_GetService: Pointer;
function GetService;
begin
GetProcedureAddress(_GetService, nsplib, 'GetService' + AWSuffix);
asm
MOV ESP, EBP
POP EBP
JMP [_GetService]
end;
end;
{$ELSE}
function EnumProtocolsA; external nsplib name 'EnumProtocolsA';
function EnumProtocolsW; external nsplib name 'EnumProtocolsW';
function EnumProtocols; external nsplib name 'EnumProtocols' + AWSuffix;
function GetAddressByNameA; external nsplib name 'GetAddressByNameA';
function GetAddressByNameW; external nsplib name 'GetAddressByNameW';
function GetAddressByName; external nsplib name 'GetAddressByName' + AWSuffix;
function GetTypeByNameA; external nsplib name 'GetTypeByNameA';
function GetTypeByNameW; external nsplib name 'GetTypeByNameW';
function GetTypeByName; external nsplib name 'GetTypeByName' + AWSuffix;
function GetNameByTypeA; external nsplib name 'GetNameByTypeA';
function GetNameByTypeW; external nsplib name 'GetNameByTypeW';
function GetNameByType; external nsplib name 'GetNameByType' + AWSuffix;
function SetServiceA; external nsplib name 'SetServiceA';
function SetServiceW; external nsplib name 'SetServiceW';
function SetService; external nsplib name 'SetService' + AWSuffix;
function GetServiceA; external nsplib name 'GetServiceA';
function GetServiceW; external nsplib name 'GetServiceW';
function GetService; external nsplib name 'GetService' + AWSuffix;
{$ENDIF DYNAMIC_LINK}
end.
Reference in New Issue View Git Blame Copy Permalink