type_scard_pack

package
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 30, 2024 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	// Syntax UUID
	TypeSmartCardPackSyntaxUUID = &uuid.UUID{TimeLow: 0xa35af600, TimeMid: 0x9cf4, TimeHiAndVersion: 0x11cd, ClockSeqHiAndReserved: 0xa0, ClockSeqLow: 0x76, Node: [6]uint8{0x8, 0x0, 0x2b, 0x2b, 0xd7, 0x11}}
	// Syntax ID
	TypeSmartCardPackSyntaxV1_0 = &dcerpc.SyntaxID{IfUUID: TypeSmartCardPackSyntaxUUID, IfVersionMajor: 1, IfVersionMinor: 0}
)
View Source 
var (
	// import guard
	GoPackage = "dcom/rdpesc"
)

Functions

func NewTypeSmartCardPackServerHandle 

func NewTypeSmartCardPackServerHandle(o TypeSmartCardPackServer) dcerpc.ServerHandle

func RegisterTypeSmartCardPackServer 

func RegisterTypeSmartCardPackServer(conn dcerpc.Conn, o TypeSmartCardPackServer, opts ...dcerpc.Option)

func TypeSmartCardPackServerHandle 

func TypeSmartCardPackServerHandle(ctx context.Context, o TypeSmartCardPackServer, opNum int, r ndr.Reader) (dcerpc.Operation, error)

Types

type CardAndDispositionCall 

type CardAndDispositionCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// dwDisposition:  The action to take on the card in the connected reader upon close.
	// This value is ignored on a BeginTransaction message call, as specified in section
	// 3.2.5.3.61.
	//
	//	+-------------------------------+------------------------------------+
	//	|                               |                                    |
	//	|             VALUE             |              MEANING               |
	//	|                               |                                    |
	//	+-------------------------------+------------------------------------+
	//	+-------------------------------+------------------------------------+
	//	| SCARD_LEAVE_CARD 0x00000000   | Do not do anything.                |
	//	+-------------------------------+------------------------------------+
	//	| SCARD_RESET_CARD 0x00000001   | Reset the smart card.              |
	//	+-------------------------------+------------------------------------+
	//	| SCARD_UNPOWER_CARD 0x00000002 | Turn off and reset the smart card. |
	//	+-------------------------------+------------------------------------+
	//	| SCARD_EJECT_CARD 0x00000003   | Eject the smart card.              |
	//	+-------------------------------+------------------------------------+
	Disposition uint32 `idl:"name:dwDisposition" json:"disposition"`
}

CardAndDispositionCall structure represents HCardAndDisposition_Call RPC structure.

The HCardAndDisposition_Call structure defines the action taken on the disposition of a smart card associated with a valid context when a connection is terminated.

func (*CardAndDispositionCall) MarshalNDR 

func (o *CardAndDispositionCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*CardAndDispositionCall) UnmarshalNDR 

func (o *CardAndDispositionCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ConnectACall 

type ConnectACall struct {
	// szReader:  An ASCII string specifying the reader name to connect to.
	Reader string `idl:"name:szReader;string" json:"reader"`
	// Common:  Additional parameters that are required for the Connect call are specified
	// in section 3.1.4.28. For more information, see section 2.2.1.3.
	Common *ConnectCommon `idl:"name:Common" json:"common"`
}

ConnectACall structure represents ConnectA_Call RPC structure.

ConnectA_Call opens a connection to the smart card located in the reader identified by a reader name.

func (*ConnectACall) MarshalNDR 

func (o *ConnectACall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ConnectACall) UnmarshalNDR 

func (o *ConnectACall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ConnectCommon 

type ConnectCommon struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// dwShareMode:  A flag that indicates whether other applications are allowed to form
	// connections to the card. Possible values of this field are specified in section 2.2.6.
	ShareMode uint32 `idl:"name:dwShareMode" json:"share_mode"`
	// dwPreferredProtocols:  A bitmask of acceptable protocols for the connection, as specified
	// in section 2.2.5.
	PreferredProtocols uint32 `idl:"name:dwPreferredProtocols" json:"preferred_protocols"`
}

ConnectCommon structure represents Connect_Common RPC structure.

The Connect_Common structure contains information common to both versions of the Connect function (for more information, see sections 2.2.2.13 and 2.2.2.14).

func (*ConnectCommon) MarshalNDR 

func (o *ConnectCommon) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ConnectCommon) UnmarshalNDR 

func (o *ConnectCommon) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ConnectReturn 

type ConnectReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// dwActiveProtocol:  A value that indicates the active smart card transmission protocol.
	// Possible values are specified in section 2.2.5.
	ActiveProtocol uint32 `idl:"name:dwActiveProtocol" json:"active_protocol"`
}

ConnectReturn structure represents Connect_Return RPC structure.

The Connect_Return structure is used to obtain return information from a Connect call (for more information, see sections 3.1.4.28 and 3.1.4.29).

func (*ConnectReturn) MarshalNDR 

func (o *ConnectReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ConnectReturn) UnmarshalNDR 

func (o *ConnectReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ConnectWCall 

type ConnectWCall struct {
	// szReader:  A Unicode string specifying the reader name to connect to.
	Reader string `idl:"name:szReader;string" json:"reader"`
	// Common:  Additional parameters that are required for the Connect call. For more information,
	// see sections 3.1.4.29 and 2.2.1.3.
	Common *ConnectCommon `idl:"name:Common" json:"common"`
}

ConnectWCall structure represents ConnectW_Call RPC structure.

The ConnectW_Call structure is used to open a connection to the smart card located in the reader identified by a reader name.

func (*ConnectWCall) MarshalNDR 

func (o *ConnectWCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ConnectWCall) UnmarshalNDR 

func (o *ConnectWCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ContextAndStringACall 

type ContextAndStringACall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// sz:  The value of this string depends on the context (based on IOCTL) in which this
	// structure is used.
	//
	//	+----------------------------------------------+-------------------+
	//	|                                              |                   |
	//	|                    VALUE                     |      MEANING      |
	//	|                                              |                   |
	//	+----------------------------------------------+-------------------+
	//	+----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_INTRODUCEREADERGROUPA 0x00090050 | Reader group name |
	//	+----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_FORGETREADERGROUPA 0x00090058    | Reader group name |
	//	+----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_FORGETREADERA 0x00090068         | Reader name       |
	//	+----------------------------------------------+-------------------+
	String string `idl:"name:sz;string" json:"string"`
}

ContextAndStringACall structure represents ContextAndStringA_Call RPC structure.

The ContextAndStringA_Call structure contains information used in calls that only require a Smart Cards for Windows context and an ASCII string.

func (*ContextAndStringACall) MarshalNDR 

func (o *ContextAndStringACall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ContextAndStringACall) UnmarshalNDR 

func (o *ContextAndStringACall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ContextAndStringWCall 

type ContextAndStringWCall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// sz:  The value of this Unicode string depends on the context (based on IOCTL) in
	// which this structure is used.
	//
	//	+----------------------------------------------+-------------------+
	//	|                                              |                   |
	//	|                    VALUE                     |      MEANING      |
	//	|                                              |                   |
	//	+----------------------------------------------+-------------------+
	//	+----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_INTRODUCEREADERGROUPW 0x00090054 | Reader group name |
	//	+----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_FORGETREADERGROUPW 0x0009005C    | Reader group name |
	//	+----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_FORGETREADERW 0x0009006C         | Reader name       |
	//	+----------------------------------------------+-------------------+
	String string `idl:"name:sz;string" json:"string"`
}

ContextAndStringWCall structure represents ContextAndStringW_Call RPC structure.

The ContextAndStringW_Call structure contains information used in calls that only require a Smart Cards for Windows context and a Unicode string.

func (*ContextAndStringWCall) MarshalNDR 

func (o *ContextAndStringWCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ContextAndStringWCall) UnmarshalNDR 

func (o *ContextAndStringWCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ContextAndTwoStringACall 

type ContextAndTwoStringACall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// sz1:  The value of this ASCII string depends on the context (based on IOCTL) in which
	// it is used.
	//
	//	+-----------------------------------------------+-------------+
	//	|                                               |             |
	//	|                     VALUE                     |   MEANING   |
	//	|                                               |             |
	//	+-----------------------------------------------+-------------+
	//	+-----------------------------------------------+-------------+
	//	| SCARD_IOCTL_INTRODUCEREADERA 0x00090060       | Reader name |
	//	+-----------------------------------------------+-------------+
	//	| SCARD_IOCTL_ADDREADERTOGROUPA 0x00090070      | Reader name |
	//	+-----------------------------------------------+-------------+
	//	| SCARD_IOCTL_REMOVEREADERFROMGROUPA 0x00090078 | Reader name |
	//	+-----------------------------------------------+-------------+
	String1 string `idl:"name:sz1;string" json:"string1"`
	// sz2:  The value of this ASCII string depends on the context (based on IOCTL) in which
	// it is used.
	//
	//	+-----------------------------------------------+-------------------+
	//	|                                               |                   |
	//	|                     VALUE                     |      MEANING      |
	//	|                                               |                   |
	//	+-----------------------------------------------+-------------------+
	//	+-----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_INTRODUCEREADERA 0x00090060       | Device name       |
	//	+-----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_ADDREADERTOGROUPA 0x00090070      | Reader group name |
	//	+-----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_REMOVEREADERFROMGROUPA 0x00090078 | Reader group name |
	//	+-----------------------------------------------+-------------------+
	String2 string `idl:"name:sz2;string" json:"string2"`
}

ContextAndTwoStringACall structure represents ContextAndTwoStringA_Call RPC structure.

The contents of the ContextAndTwoStringA_Call structure are used in those calls that require a valid Smart Cards for Windows context (as specified in section 3.2.5) and two strings (friendly names).

func (*ContextAndTwoStringACall) MarshalNDR 

func (o *ContextAndTwoStringACall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ContextAndTwoStringACall) UnmarshalNDR 

func (o *ContextAndTwoStringACall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ContextAndTwoStringWCall 

type ContextAndTwoStringWCall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// sz1:  The value of this Unicode string depends on the context (based on IOCTL) in
	// which it is used.
	//
	//	+-----------------------------------------------+-------------+
	//	|                                               |             |
	//	|                     VALUE                     |   MEANING   |
	//	|                                               |             |
	//	+-----------------------------------------------+-------------+
	//	+-----------------------------------------------+-------------+
	//	| SCARD_IOCTL_INTRODUCEREADERW 0x00090064       | Reader name |
	//	+-----------------------------------------------+-------------+
	//	| SCARD_IOCTL_ADDREADERTOGROUPW 0x00090074      | Reader name |
	//	+-----------------------------------------------+-------------+
	//	| SCARD_IOCTL_REMOVEREADERFROMGROUPW 0x0009007C | Reader name |
	//	+-----------------------------------------------+-------------+
	String1 string `idl:"name:sz1;string" json:"string1"`
	// sz2:  The value of this Unicode string depends on the context (based on IOCTL) in
	// which it is used.
	//
	//	+-----------------------------------------------+-------------------+
	//	|                                               |                   |
	//	|                     VALUE                     |      MEANING      |
	//	|                                               |                   |
	//	+-----------------------------------------------+-------------------+
	//	+-----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_INTRODUCEREADERW 0x00090064       | Device name       |
	//	+-----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_ADDREADERTOGROUPW 0x00090074      | Reader group name |
	//	+-----------------------------------------------+-------------------+
	//	| SCARD_IOCTL_REMOVEREADERFROMGROUPW 0x0009007C | Reader group name |
	//	+-----------------------------------------------+-------------------+
	String2 string `idl:"name:sz2;string" json:"string2"`
}

ContextAndTwoStringWCall structure represents ContextAndTwoStringW_Call RPC structure.

The contents of the ContextAndTwoStringW_Call structure is used in those calls that require a valid Smart Cards for Windows context (as specified in section 3.2.5) and two strings (friendly names).

func (*ContextAndTwoStringWCall) MarshalNDR 

func (o *ContextAndTwoStringWCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ContextAndTwoStringWCall) UnmarshalNDR 

func (o *ContextAndTwoStringWCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ContextCall 

type ContextCall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
}

ContextCall structure represents Context_Call RPC structure.

The Context_Call structure contains Smart Cards for Windows context.

func (*ContextCall) MarshalNDR 

func (o *ContextCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ContextCall) UnmarshalNDR 

func (o *ContextCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ControlCall 

type ControlCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// dwControlCode:  The control code for the operation. These values are specific to
	// the hardware device. This protocol MUST NOT restrict or define any values for this
	// control codes.
	ControlCode uint32 `idl:"name:dwControlCode" json:"control_code"`
	// cbInBufferSize:  The size in bytes of the pvInBuffer field.
	InBufferLength uint32 `idl:"name:cbInBufferSize" json:"in_buffer_length"`
	// pvInBuffer:  A buffer that contains the data required to perform the operation. This
	// field SHOULD be NULL if the dwControlCode field specifies an operation that does
	// not require input data. Otherwise, this data is specific to the function being performed.
	InBuffer []byte `idl:"name:pvInBuffer;size_is:(cbInBufferSize);pointer:unique" json:"in_buffer"`
	// fpvOutBufferIsNULL:  A Boolean value specifying whether the caller wants to retrieve
	// the length of the data. MUST be set to TRUE (0x00000001) if the caller wants only
	// to retrieve the length of the data; otherwise, it MUST be set to FALSE (0x00000000).
	//
	//	+-------+------------+
	//	|       |            |
	//	| NAME  |   VALUE    |
	//	|       |            |
	//	+-------+------------+
	//	+-------+------------+
	//	| FALSE | 0x00000000 |
	//	+-------+------------+
	//	| TRUE  | 0x00000001 |
	//	+-------+------------+
	OutBufferIsNull int32 `idl:"name:fpvOutBufferIsNULL" json:"out_buffer_is_null"`
	// cbOutBufferSize:  The maximum size of the buffer to be returned. This field MUST
	// be ignored if fpvOutBufferIsNULL is set to TRUE (0x00000001).
	OutBufferLength uint32 `idl:"name:cbOutBufferSize" json:"out_buffer_length"`
}

ControlCall structure represents Control_Call RPC structure.

Normally, communication is to the smart card via the reader. However, in some cases, the ability to communicate directly with the smart card reader is requested. The Control_Call structure provides the ability to talk to the reader.

func (*ControlCall) MarshalNDR 

func (o *ControlCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ControlCall) UnmarshalNDR 

func (o *ControlCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ControlReturn 

type ControlReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// cbOutBufferSize:  The number of bytes in the pvOutBuffer field.
	OutBufferLength uint32 `idl:"name:cbOutBufferSize" json:"out_buffer_length"`
	// pvOutBuffer:  Contains the return data specific to the value of the Control_Call
	// structure.
	OutBuffer []byte `idl:"name:pvOutBuffer;size_is:(cbOutBufferSize);pointer:unique" json:"out_buffer"`
}

ControlReturn structure represents Control_Return RPC structure.

The Control_Return structure is used to obtain information from a Control_Call (for more information, see section 3.1.4.37).

func (*ControlReturn) MarshalNDR 

func (o *ControlReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ControlReturn) UnmarshalNDR 

func (o *ControlReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type EstablishContextCall 

type EstablishContextCall struct {
	// dwScope:  The scope of the context that will be established. The following table
	// shows valid values of this field.
	//
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	|                                 |                                                                                  |
	//	|              VALUE              |                                     MEANING                                      |
	//	|                                 |                                                                                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| SCARD_SCOPE_USER 0x00000000     | The context is a user context; any database operations MUST be performed with    |
	//	|                                 | the domain of the user.                                                          |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| SCARD_SCOPE_TERMINAL 0x00000001 | The context is a terminal context; any database operations MUST be performed     |
	//	|                                 | with the domain of the terminal. This flag is currently unused; it is here for   |
	//	|                                 | compatibility with [PCSC5] section 3.1.3.                                        |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| SCARD_SCOPE_SYSTEM 0x00000002   | The context is the system context; any database operations MUST be performed     |
	//	|                                 | within the domain of the system.                                                 |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	Scope uint32 `idl:"name:dwScope" json:"scope"`
}

EstablishContextCall structure represents EstablishContext_Call RPC structure.

The EstablishContext_Call structure is used to specify the scope of Smart Cards for Windows context to be created (for more information, see section 3.1.4.1).

func (*EstablishContextCall) MarshalNDR 

func (o *EstablishContextCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EstablishContextCall) UnmarshalNDR 

func (o *EstablishContextCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type EstablishContextReturn 

type EstablishContextReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
}

EstablishContextReturn structure represents EstablishContext_Return RPC structure.

The EstablishContext_Return structure is used to provide a response to an Establish Context call (for more information, see section 3.1.4.1.)

func (*EstablishContextReturn) MarshalNDR 

func (o *EstablishContextReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*EstablishContextReturn) UnmarshalNDR 

func (o *EstablishContextReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type GetAttributeCall 

type GetAttributeCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// dwAttrId:  An identifier for the attribute to get. For more information on defined
	// attributes, see [PCSC3] section 3.1.2.
	AttributeID uint32 `idl:"name:dwAttrId" json:"attribute_id"`
	// fpbAttrIsNULL:  A Boolean value specifying whether the caller wants to retrieve the
	// length of the data. Set to FALSE (0x00000000) in order to allow the data to be returned.
	// Set to TRUE (0x00000001) and only the length of the data will be returned.
	//
	//	+-------+------------+
	//	|       |            |
	//	| NAME  |   VALUE    |
	//	|       |            |
	//	+-------+------------+
	//	+-------+------------+
	//	| FALSE | 0x00000000 |
	//	+-------+------------+
	//	| TRUE  | 0x00000001 |
	//	+-------+------------+
	AttributeIsNull int32 `idl:"name:fpbAttrIsNULL" json:"attribute_is_null"`
	// cbAttrLen:  The length of the buffer specified on the TS Server side. If cbAttrLen
	// is set to SCARD_AUTOALLOCATE with a value of 0xFFFFFFFF then any buffer length can
	// be returned. Otherwise, the returned buffer MUST NOT exceed cbAttrLen bytes in length.
	// When the buffer to be returned exceeds cbAttrLen bytes in length, GetAttrib_Return.ReturnCode
	// MUST be set to SCARD_E_INSUFFICIENT_BUFFER (0x80100008). The cbAttrLen field MUST
	// be ignored if fpbAttrIsNULL is set to TRUE (0x00000001). Also, if fpbAttrIsNULL is
	// set to FALSE (0x00000000) but cbAttrLen is set to 0x00000000, then the call MUST
	// succeed, GetAttrib_Return.cbAttrLen MUST be set to the length of the data, in bytes,
	// and GetAttrib_Return.pbAttr MUST be set to NULL.
	AttributeLength uint32 `idl:"name:cbAttrLen" json:"attribute_length"`
}

GetAttributeCall structure represents GetAttrib_Call RPC structure.

The GetAttrib_Call structure is used to read smart card reader attributes.

func (*GetAttributeCall) MarshalNDR 

func (o *GetAttributeCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetAttributeCall) UnmarshalNDR 

func (o *GetAttributeCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type GetAttributeReturn 

type GetAttributeReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// cbAttrLen:  The number of bytes in the pbAttr field.
	AttributeLength uint32 `idl:"name:cbAttrLen" json:"attribute_length"`
	// pbAttr:  A pointer to an array that contains any values returned from the corresponding
	// call.
	Attribute []byte `idl:"name:pbAttr;size_is:(cbAttrLen);pointer:unique" json:"attribute"`
}

GetAttributeReturn structure represents GetAttrib_Return RPC structure.

The GetAttrib_Return structure defines attribute information from a smart card reader (for more information, see section 3.1.4.38).

func (*GetAttributeReturn) MarshalNDR 

func (o *GetAttributeReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetAttributeReturn) UnmarshalNDR 

func (o *GetAttributeReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type GetStatusChangeACall 

type GetStatusChangeACall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// dwTimeOut:  The maximum amount of time, in milliseconds, to wait for an action. If
	// this member is set to 0xFFFFFFFF (INFINITE), the caller MUST wait until an action
	// occurs.
	Timeout uint32 `idl:"name:dwTimeOut" json:"timeout"`
	// cReaders:  The number of ReaderStates to track.
	ReadersCount uint32 `idl:"name:cReaders" json:"readers_count"`
	// rgReaderStates:  Smart card readers that the caller is tracking.
	ReaderStates []*ReaderStateA `idl:"name:rgReaderStates;size_is:(cReaders)" json:"reader_states"`
}

GetStatusChangeACall structure represents GetStatusChangeA_Call RPC structure.

The GetStatusChangeA_Call structure provides the state change in the reader as specified in section 3.1.4.23.

func (*GetStatusChangeACall) MarshalNDR 

func (o *GetStatusChangeACall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetStatusChangeACall) UnmarshalNDR 

func (o *GetStatusChangeACall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type GetStatusChangeReturn 

type GetStatusChangeReturn struct {
	ReturnCode   int32                `idl:"name:ReturnCode" json:"return_code"`
	ReadersCount uint32               `idl:"name:cReaders" json:"readers_count"`
	ReaderStates []*ReaderStateReturn `idl:"name:rgReaderStates;size_is:(cReaders)" json:"reader_states"`
}

GetStatusChangeReturn structure represents GetStatusChange_Return RPC structure.

func (*GetStatusChangeReturn) MarshalNDR 

func (o *GetStatusChangeReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetStatusChangeReturn) UnmarshalNDR 

func (o *GetStatusChangeReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type GetStatusChangeWCall 

type GetStatusChangeWCall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// dwTimeOut:  Maximum amount of time, in milliseconds, to wait for an action. If set
	// to 0xFFFFFFFF (INFINITE), the caller MUST wait until an action occurs.
	Timeout uint32 `idl:"name:dwTimeOut" json:"timeout"`
	// cReaders:  The number of ReaderStates to track.
	ReadersCount uint32 `idl:"name:cReaders" json:"readers_count"`
	// rgReaderStates:  Smart card readers that the caller is tracking.
	ReaderStates []*ReaderStateW `idl:"name:rgReaderStates;size_is:(cReaders)" json:"reader_states"`
}

GetStatusChangeWCall structure represents GetStatusChangeW_Call RPC structure.

The GetStatusChangeW_Call structure provides the state change in the Reader as specified in section 3.1.4.24.

func (*GetStatusChangeWCall) MarshalNDR 

func (o *GetStatusChangeWCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetStatusChangeWCall) UnmarshalNDR 

func (o *GetStatusChangeWCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type GetTransmitCountCall 

type GetTransmitCountCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
}

GetTransmitCountCall structure represents GetTransmitCount_Call RPC structure.

The GetTransmitCount_Call structure is used to obtain the number of transmit calls sent to the card since the reader was introduced.

func (*GetTransmitCountCall) MarshalNDR 

func (o *GetTransmitCountCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetTransmitCountCall) UnmarshalNDR 

func (o *GetTransmitCountCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type GetTransmitCountReturn 

type GetTransmitCountReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// cTransmitCount:  The field specifies the number of successful Transmit calls (for
	// more information, see section 3.1.4.35) performed on the reader since it was introduced
	// to the system.
	TransmitCount uint32 `idl:"name:cTransmitCount" json:"transmit_count"`
}

GetTransmitCountReturn structure represents GetTransmitCount_Return RPC structure.

The GetTransmitCount_Return structure defines the number of transmit calls that were performed on the smart card reader (for more information, see section 3.1.4.41).

func (*GetTransmitCountReturn) MarshalNDR 

func (o *GetTransmitCountReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*GetTransmitCountReturn) UnmarshalNDR 

func (o *GetTransmitCountReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ListReaderGroupsCall 

type ListReaderGroupsCall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// fmszGroupsIsNULL:  A Boolean value specifying whether the caller wants to retrieve
	// just the length of the data. Set to FALSE (0x00000000) in order to allow the data
	// to be returned. Set to TRUE (0x00000001) and only the length of the data will be
	// returned.
	GroupsIsNull int32 `idl:"name:fmszGroupsIsNULL" json:"groups_is_null"`
	// cchGroups:  The length of the string buffer specified by the caller. If cchGroups
	// is set to SCARD_AUTOALLOCATE with a value of 0xFFFFFFFF, a string of any length can
	// be returned. Otherwise, the returned string MUST NOT exceed cchGroups characters
	// in length, including any null characters. When the string to be returned exceeds
	// cchGroups characters in length, including any null characters, ListReaderGroups_Return.ReturnCode
	// MUST be set to SCARD_E_INSUFFICIENT_BUFFER (0x80100008). The cchGroups field MUST
	// be ignored if fmszGroupsIsNULL is set to TRUE (0x00000001). Also, if fmszGroupsIsNULL
	// is set to FALSE (0x00000000) but cchGroups is set to 0x00000000, then the call MUST
	// succeed, ListReaderGroups_Return.cBytes MUST be set to the length of the data, in
	// bytes, and ListReaderGroups_Return.msz MUST be set to NULL.
	GroupsLength uint32 `idl:"name:cchGroups" json:"groups_length"`
}

ListReaderGroupsCall structure represents ListReaderGroups_Call RPC structure.

The ListReaderGroups_Call structure contains the parameters for the List Readers Groups call (for more information, see sections 3.1.4.5 and 3.1.4.6).

func (*ListReaderGroupsCall) MarshalNDR 

func (o *ListReaderGroupsCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ListReaderGroupsCall) UnmarshalNDR 

func (o *ListReaderGroupsCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ListReaderGroupsReturn 

type ListReaderGroupsReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. The value returned from the Smart Card
	// Redirection call.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// cBytes:  The number of bytes in the msz array field.
	BytesCount uint32 `idl:"name:cBytes" json:"bytes_count"`
	// msz:  The meaning of this field is specific to the context (IOCTL) in which it is
	// used.
	//
	//	+------------------------------------------+-----------------------------------------------------+
	//	|                                          |                                                     |
	//	|                  VALUE                   |                       MEANING                       |
	//	|                                          |                                                     |
	//	+------------------------------------------+-----------------------------------------------------+
	//	+------------------------------------------+-----------------------------------------------------+
	//	| SCARD_IOCTL_LISTREADERSA 0x00090028      | ASCII multistring of readers on the system.         |
	//	+------------------------------------------+-----------------------------------------------------+
	//	| SCARD_IOCTL_LISTREADERSW 0x0009002C      | Unicode multistring of readers on the system.       |
	//	+------------------------------------------+-----------------------------------------------------+
	//	| SCARD_IOCTL_LISTREADERGROUPSA 0x00090020 | ASCII multistring of reader groups on the system.   |
	//	+------------------------------------------+-----------------------------------------------------+
	//	| SCARD_IOCTL_LISTREADERGROUPSW 0x00090024 | Unicode multistring of reader groups on the system. |
	//	+------------------------------------------+-----------------------------------------------------+
	Multistring []byte `idl:"name:msz;size_is:(cBytes);pointer:unique" json:"multistring"`
}

ListReaderGroupsReturn structure represents ListReaderGroups_Return RPC structure.

The ListReaderGroups_Return and ListReaders_Return structures are used to obtain results for those calls that return a multistring, in addition to a long return value. For more information, see sections 3.1.4.5, 3.1.4.6, 3.1.4.7, and 3.1.4.8.

func (*ListReaderGroupsReturn) MarshalNDR 

func (o *ListReaderGroupsReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ListReaderGroupsReturn) UnmarshalNDR 

func (o *ListReaderGroupsReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ListReadersCall 

type ListReadersCall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// cBytes:  The length, in bytes, of reader groups specified in mszGroups.
	BytesCount uint32 `idl:"name:cBytes" json:"bytes_count"`
	// mszGroups:  The names of the reader groups defined in the system. Reader groups not
	// present on the protocol server MUST be ignored. The value of this is dependent on
	// the context (IOCTL) that it is used.
	//
	//	+-------------------------------------+---------------------+
	//	|                                     |                     |
	//	|                VALUE                |       MEANING       |
	//	|                                     |                     |
	//	+-------------------------------------+---------------------+
	//	+-------------------------------------+---------------------+
	//	| SCARD_IOCTL_LISTREADERSA 0x00090028 | ASCII multistring   |
	//	+-------------------------------------+---------------------+
	//	| SCARD_IOCTL_LISTREADERSW 0x0009002C | Unicode multistring |
	//	+-------------------------------------+---------------------+
	Groups []byte `idl:"name:mszGroups;size_is:(cBytes);pointer:unique" json:"groups"`
	// fmszReadersIsNULL:  A Boolean value specifying whether the caller wants to retrieve
	// the length of the data. Set to FALSE (0x00000000) to allow the data to be returned.
	// Set to TRUE (0x00000001), and only the length of the data will be returned.
	ReadersIsNull int32 `idl:"name:fmszReadersIsNULL" json:"readers_is_null"`
	// cchReaders:  The length of the string buffer specified by the caller. If cchReaders
	// is set to SCARD_AUTOALLOCATE with a value of 0xFFFFFFFF, a string of any length can
	// be returned. Otherwise, the returned string MUST NOT exceed cchReaders characters
	// in length, including any NULL characters. When the string to be returned exceeds
	// cchReaders characters in length, including any null characters, ListReaders_Return.ReturnCode
	// MUST be set to SCARD_E_INSUFFICIENT_BUFFER (0x80100008). The cchReaders field MUST
	// be ignored if fmszReadersIsNULL is set to TRUE (0x00000001). Also, if fmszReadersIsNULL
	// is set to FALSE (0x00000000) but cchReaders is set to 0x00000000, then the call MUST
	// succeed, ListReaders_Return.cBytes MUST be set to the length of the data in bytes,
	// and ListReaders_Return.msz MUST be set to NULL.
	ReadersLength uint32 `idl:"name:cchReaders" json:"readers_length"`
}

ListReadersCall structure represents ListReaders_Call RPC structure.

The ListReaders_Call structure contains the parameters for the List Readers call (for more information, see sections 3.1.4.7 and 3.1.4.8).

func (*ListReadersCall) MarshalNDR 

func (o *ListReadersCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ListReadersCall) UnmarshalNDR 

func (o *ListReadersCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ListReadersReturn 

type ListReadersReturn struct {
	ReturnCode  int32  `idl:"name:ReturnCode" json:"return_code"`
	BytesCount  uint32 `idl:"name:cBytes" json:"bytes_count"`
	Multistring []byte `idl:"name:msz;size_is:(cBytes);pointer:unique" json:"multistring"`
}

ListReadersReturn structure represents ListReaders_Return RPC structure.

func (*ListReadersReturn) MarshalNDR 

func (o *ListReadersReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ListReadersReturn) UnmarshalNDR 

func (o *ListReadersReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type LocateCardsACall 

type LocateCardsACall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// cBytes:  The number of bytes in the mszCards field.
	BytesCount uint32 `idl:"name:cBytes" json:"bytes_count"`
	// mszCards:  An ASCII multistring of card names to locate. Card names MUST be registered
	// in Smart Cards for Windows. Unknown card types MUST be ignored.
	Cards []byte `idl:"name:mszCards;size_is:(cBytes)" json:"cards"`
	// cReaders:  The number of reader state structures.
	ReadersCount uint32 `idl:"name:cReaders" json:"readers_count"`
	// rgReaderStates:  The reader state information specifying which readers are searched
	// for the cards listed in mszCards.
	ReaderStates []*ReaderStateA `idl:"name:rgReaderStates;size_is:(cReaders)" json:"reader_states"`
}

LocateCardsACall structure represents LocateCardsA_Call RPC structure.

The parameters of the LocateCardsA_Call structure specify the list of smart card readers to search for the specified card types. For call information, see section 3.1.4.21.

func (*LocateCardsACall) MarshalNDR 

func (o *LocateCardsACall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*LocateCardsACall) UnmarshalNDR 

func (o *LocateCardsACall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type LocateCardsAttributeMask 

type LocateCardsAttributeMask struct {
	// cbAtr:  The number of bytes used in the rgbAtr and rgbMask fields.
	AttributeLength uint32 `idl:"name:cbAtr" json:"attribute_length"`
	// rgbAtr:  Values for the card's Answer To Reset (ATR) string. This value MUST be formatted
	// as specified in [ISO/IEC-7816-3] section 8. Unused bytes MUST be set to 0 and MUST
	// be ignored.
	Attribute []byte `idl:"name:rgbAtr" json:"attribute"`
	// rgbMask:  Values for the mask for the card's ATR string. Each bit that cannot vary
	// between cards of the same type MUST be set to 1. Unused bytes MUST be set to 0 and
	// MUST be ignored.
	Mask []byte `idl:"name:rgbMask" json:"mask"`
}

LocateCardsAttributeMask structure represents LocateCards_ATRMask RPC structure.

The LocateCards_ATRMask structure contains the information to identify a card type.

func (*LocateCardsAttributeMask) MarshalNDR 

func (o *LocateCardsAttributeMask) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*LocateCardsAttributeMask) UnmarshalNDR 

func (o *LocateCardsAttributeMask) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type LocateCardsByAtraCall 

type LocateCardsByAtraCall struct {
	// Context:  A valid context, as specified in section 2.2.2.13.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// cAtrs:  The number of bytes in the rgAtrMasks field.
	AttributesCount uint32 `idl:"name:cAtrs" json:"attributes_count"`
	// rgAtrMasks:  An array of ATRs to match against currently inserted cards.
	AttributeMasks []*LocateCardsAttributeMask `idl:"name:rgAtrMasks;size_is:(cAtrs)" json:"attribute_masks"`
	// cReaders:  The number of elements in the rgReaderStates field.
	ReadersCount uint32 `idl:"name:cReaders" json:"readers_count"`
	// rgReaderStates:  The states of the readers that the application is monitoring. The
	// states reflect what the application determines to be the current states of the readers
	// and that might differ from the actual states.
	ReaderStates []*ReaderStateA `idl:"name:rgReaderStates;size_is:(cReaders)" json:"reader_states"`
}

LocateCardsByAtraCall structure represents LocateCardsByATRA_Call RPC structure.

The LocateCardsByATRA_Call structure returns information concerning the status of the smart card of interest (ATR).

func (*LocateCardsByAtraCall) MarshalNDR 

func (o *LocateCardsByAtraCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*LocateCardsByAtraCall) UnmarshalNDR 

func (o *LocateCardsByAtraCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type LocateCardsByAtrwCall 

type LocateCardsByAtrwCall struct {
	// Context:  A valid context, as specified in section 2.2.2.14.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// cAtrs:  The number of bytes in the rgAtrMasks field.
	AttributesCount uint32 `idl:"name:cAtrs" json:"attributes_count"`
	// rgAtrMasks:  An array of ATRs to match against currently inserted cards.
	AttributeMasks []*LocateCardsAttributeMask `idl:"name:rgAtrMasks;size_is:(cAtrs)" json:"attribute_masks"`
	// cReaders:  The number of elements in the rgReaderStates field.
	ReadersCount uint32 `idl:"name:cReaders" json:"readers_count"`
	// rgReaderStates:  The states of the readers that the application is monitoring. The
	// states reflects what the application believes is the current states of the readers
	// and might differ from the actual states.
	ReaderStates []*ReaderStateW `idl:"name:rgReaderStates;size_is:(cReaders)" json:"reader_states"`
}

LocateCardsByAtrwCall structure represents LocateCardsByATRW_Call RPC structure.

The LocateCardsByATRW_Call structure returns information concerning the status of the smart card of interest (ATR).

func (*LocateCardsByAtrwCall) MarshalNDR 

func (o *LocateCardsByAtrwCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*LocateCardsByAtrwCall) UnmarshalNDR 

func (o *LocateCardsByAtrwCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type LocateCardsReturn 

type LocateCardsReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// cReaders:  The number of elements in the rgReaderStates field.
	ReadersCount uint32 `idl:"name:cReaders" json:"readers_count"`
	// rgReaderStates:  The current states of the readers being watched.
	ReaderStates []*ReaderStateReturn `idl:"name:rgReaderStates;size_is:(cReaders)" json:"reader_states"`
}

LocateCardsReturn structure represents LocateCards_Return RPC structure.

The LocateCards_Return and GetStatusChange_Return structures are used to obtain the results on those calls that return updated reader state information. (for more information, see sections 3.1.4.21, 3.1.4.22, 3.1.4.23, 3.1.4.24, 3.1.4.25, and 3.1.4.26).

func (*LocateCardsReturn) MarshalNDR 

func (o *LocateCardsReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*LocateCardsReturn) UnmarshalNDR 

func (o *LocateCardsReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type LocateCardsWCall 

type LocateCardsWCall struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// cBytes:  The number of bytes in the mszCards field.
	BytesCount uint32 `idl:"name:cBytes" json:"bytes_count"`
	// mszCards:  A Unicode multistring of card names to locate. Card names MUST be registered
	// in Smart Cards for Windows. Unknown card types MUST be ignored.
	Cards []byte `idl:"name:mszCards;size_is:(cBytes)" json:"cards"`
	// cReaders:  The number of reader state structures.
	ReadersCount uint32 `idl:"name:cReaders" json:"readers_count"`
	// rgReaderStates:  The reader state information used to locate the cards listed in
	// mszCards.
	ReaderStates []*ReaderStateW `idl:"name:rgReaderStates;size_is:(cReaders)" json:"reader_states"`
}

LocateCardsWCall structure represents LocateCardsW_Call RPC structure.

The parameters of the LocateCardsW_Call structure specify the list of smart card readers to search for the specified card types. For more information, see section 3.1.4.22.

func (*LocateCardsWCall) MarshalNDR 

func (o *LocateCardsWCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*LocateCardsWCall) UnmarshalNDR 

func (o *LocateCardsWCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type LongReturn 

type LongReturn struct {
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
}

LongReturn structure represents long_Return RPC structure.

func (*LongReturn) MarshalNDR 

func (o *LongReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*LongReturn) UnmarshalNDR 

func (o *LongReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReadCacheACall 

type ReadCacheACall struct {
	// szLookupName:  An ASCII string containing the lookup name.
	LookupName string `idl:"name:szLookupName;string" json:"lookup_name"`
	// Common:  Additional parameters for the Read Cache call (for additional information,
	// see section 3.1.4.42), as specified in section 2.2.1.9.
	Common *ReadCacheCommon `idl:"name:Common" json:"common"`
}

ReadCacheACall structure represents ReadCacheA_Call RPC structure.

The ReadCacheA_Call structure is used to obtain the card and reader information from the cache.

func (*ReadCacheACall) MarshalNDR 

func (o *ReadCacheACall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReadCacheACall) UnmarshalNDR 

func (o *ReadCacheACall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReadCacheCommon 

type ReadCacheCommon struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// CardIdentifier:  A UUID that specifies the name of the smart card with which the
	// name-value pair is associated.
	CardID *dtyp.UUID `idl:"name:CardIdentifier" json:"card_id"`
	// FreshnessCounter:  A value specifying the current revision of the data.
	FreshnessCounter uint32 `idl:"name:FreshnessCounter" json:"freshness_counter"`
	// fPbDataIsNULL:  A Boolean value specifying whether the caller wants to retrieve the
	// length of the data. It MUST be set to TRUE (0x00000001) if the caller wants only
	// to retrieve the length of the data; otherwise, it MUST be set to FALSE (0x00000000).
	DataIsNull int32 `idl:"name:fPbDataIsNULL" json:"data_is_null"`
	// cbDataLen:  The length of the buffer specified on the server side. If cbDataLen is
	// set to SCARD_AUTOALLOCATE with a value of 0xFFFFFFFF, a buffer of any length can
	// be returned. Otherwise, the returned buffer MUST NOT exceed cbDataLen bytes. This
	// field MUST be ignored if fPbDataIsNULL is set to TRUE (0x00000001).
	DataLength uint32 `idl:"name:cbDataLen" json:"data_length"`
}

ReadCacheCommon structure represents ReadCache_Common RPC structure.

The ReadCache_Common structure contains information common to both the ReadCacheA_Call and ReadCacheW_Call structures.

func (*ReadCacheCommon) MarshalNDR 

func (o *ReadCacheCommon) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReadCacheCommon) UnmarshalNDR 

func (o *ReadCacheCommon) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReadCacheReturn 

type ReadCacheReturn struct {
	// ReturnCode:  HRESULT or Win32 Error codes. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// cbDataLen:  The number of bytes in the pbData field.
	DataLength uint32 `idl:"name:cbDataLen" json:"data_length"`
	// pbData:  The value of the look up item.
	Data []byte `idl:"name:pbData;size_is:(cbDataLen);pointer:unique" json:"data"`
}

ReadCacheReturn structure represents ReadCache_Return RPC structure.

The ReadCache_Return structure is used to obtain the data that corresponds to the lookup item requested in ReadCacheA_Call as specified in section 2.2.2.25, or ReadCacheW_Call as specified in section 2.2.2.26. For more call information, see sections 3.1.4.42 and 3.1.4.43.

func (*ReadCacheReturn) MarshalNDR 

func (o *ReadCacheReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReadCacheReturn) UnmarshalNDR 

func (o *ReadCacheReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReadCacheWCall 

type ReadCacheWCall struct {
	// szLookupName:  A Unicode string containing the lookup name.
	LookupName string `idl:"name:szLookupName;string" json:"lookup_name"`
	// Common:  Additional parameters for the Read Cache call (for additional information,
	// see section 3.1.4.43), as specified in section 2.2.1.9.
	Common *ReadCacheCommon `idl:"name:Common" json:"common"`
}

ReadCacheWCall structure represents ReadCacheW_Call RPC structure.

The ReadCacheW_Call structure is used to obtain the card and reader information from the cache.

func (*ReadCacheWCall) MarshalNDR 

func (o *ReadCacheWCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReadCacheWCall) UnmarshalNDR 

func (o *ReadCacheWCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReaderSmartCardContext 

type ReaderSmartCardContext struct {
	// cbContext:  The number of bytes in the pbContext field.
	ContextLength uint32 `idl:"name:cbContext" json:"context_length"`
	// pbContext:  An array of cbContext bytes that contains Smart Cards for Windows context.
	// The data is implementation-specific and MUST NOT be interpreted or changed on the
	// Protocol server.
	Context []byte `idl:"name:pbContext;size_is:(cbContext);pointer:unique" json:"context"`
}

ReaderSmartCardContext structure represents REDIR_SCARDCONTEXT RPC structure.

REDIR_SCARDCONTEXT represents a context to Smart Cards for Windows on the TS client.

func (*ReaderSmartCardContext) MarshalNDR 

func (o *ReaderSmartCardContext) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReaderSmartCardContext) UnmarshalNDR 

func (o *ReaderSmartCardContext) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReaderSmartCardHandle 

type ReaderSmartCardHandle struct {
	// Context:  A valid context, as specified in REDIR_SCARDCONTEXT.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// cbHandle:  The number of bytes in the pbHandle field.
	HandleLength uint32 `idl:"name:cbHandle" json:"handle_length"`
	// pbHandle:  An array of cbHandle bytes that corresponds to a smart card reader handle
	// on the TS client. The data is implementation-specific and MUST NOT be interpreted
	// or changed on the Protocol server.
	Handle []byte `idl:"name:pbHandle;size_is:(cbHandle)" json:"handle"`
}

ReaderSmartCardHandle structure represents REDIR_SCARDHANDLE RPC structure.

REDIR_SCARDHANDLE represents a smart card reader handle associated with Smart Cards for Windows context.

func (*ReaderSmartCardHandle) MarshalNDR 

func (o *ReaderSmartCardHandle) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReaderSmartCardHandle) UnmarshalNDR 

func (o *ReaderSmartCardHandle) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReaderStateA 

type ReaderStateA struct {
	// szReader:  An ASCII string specifying the reader name.
	Reader string `idl:"name:szReader;string" json:"reader"`
	// Common:  A packet that specifies the state of the reader at the time of the call.
	// For information about this packet, see section 2.2.1.5.
	Common *ReaderStateCommonCall `idl:"name:Common" json:"common"`
}

ReaderStateA structure represents ReaderStateA RPC structure.

The ReaderStateA structure contains information used in calls that only require Smart Cards for Windows context and an ASCII string.

func (*ReaderStateA) MarshalNDR 

func (o *ReaderStateA) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReaderStateA) UnmarshalNDR 

func (o *ReaderStateA) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReaderStateCommonCall 

type ReaderStateCommonCall struct {
	// dwCurrentState:  A bitmap that specifies the current reader state according to the
	// TS client. Possible values are specified in section 2.2.7.
	CurrentState uint32 `idl:"name:dwCurrentState" json:"current_state"`
	// dwEventState:  A bitmap that defines the state of the reader after a state change.
	// Possible values are specified in section 2.2.7.
	EventState uint32 `idl:"name:dwEventState" json:"event_state"`
	// cbAtr:  The number of bytes used in the ATR string.
	AttributeLength uint32 `idl:"name:cbAtr" json:"attribute_length"`
	// rgbAtr:  The value for the card's ATR string. If cbAtr is NOT zero, this value MUST
	// be formatted in accordance to [ISO/IEC-7816-3] section 8. Unused bytes MUST be set
	// to 0 and MUST be ignored.
	Attribute []byte `idl:"name:rgbAtr" json:"attribute"`
}

ReaderStateCommonCall structure represents ReaderState_Common_Call RPC structure.

The ReaderState_Common_Call structure contains the state of the reader at the time of the call as seen by the caller.

func (*ReaderStateCommonCall) MarshalNDR 

func (o *ReaderStateCommonCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReaderStateCommonCall) UnmarshalNDR 

func (o *ReaderStateCommonCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReaderStateReturn 

type ReaderStateReturn struct {
	// dwCurrentState:  A bitmap that defines the current state of the reader at the time
	// of the call. Possible values are specified in section 2.2.7.
	CurrentState uint32 `idl:"name:dwCurrentState" json:"current_state"`
	// dwEventState:  A bitmap that defines the state of the reader after a state change
	// as seen by Smart Cards for Windows. Possible values are specified in section 2.2.7.
	EventState uint32 `idl:"name:dwEventState" json:"event_state"`
	// cbAtr:  The number of used bytes in rgbAtr.
	AttributeLength uint32 `idl:"name:cbAtr" json:"attribute_length"`
	// rgbAtr:  The values for the card's ATR string. Unused bytes MUST be set to zero and
	// MUST be ignored on receipt.
	Attribute []byte `idl:"name:rgbAtr" json:"attribute"`
}

ReaderStateReturn structure represents ReaderState_Return RPC structure.

The ReaderState_Return structure specifies state information returned from Smart Cards for Windows.

func (*ReaderStateReturn) MarshalNDR 

func (o *ReaderStateReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReaderStateReturn) UnmarshalNDR 

func (o *ReaderStateReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReaderStateW 

type ReaderStateW struct {
	// szReader:  A Unicode string specifying the reader name.
	Reader string `idl:"name:szReader;string" json:"reader"`
	// Common:  A packet that specifies the state of the reader at the time of the call.
	// For information about this packet, see section 2.2.1.5.
	Common *ReaderStateCommonCall `idl:"name:Common" json:"common"`
}

ReaderStateW structure represents ReaderStateW RPC structure.

The ReaderStateW structure is a Unicode representation of the state of a smart card reader.

func (*ReaderStateW) MarshalNDR 

func (o *ReaderStateW) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReaderStateW) UnmarshalNDR 

func (o *ReaderStateW) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReconnectCall 

type ReconnectCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// dwShareMode:  A flag that indicates whether other applications can form connections
	// to this card. For acceptable values of this field, see section 2.2.6.
	ShareMode uint32 `idl:"name:dwShareMode" json:"share_mode"`
	// dwPreferredProtocols:  A bit mask of acceptable protocols for this connection. For
	// specifics on possible values, see section 2.2.5.
	PreferredProtocols uint32 `idl:"name:dwPreferredProtocols" json:"preferred_protocols"`
	// dwInitialization:  A type of initialization that SHOULD be performed on the card.
	//
	//	+-------------------------------+------------------------------------+
	//	|                               |                                    |
	//	|             VALUE             |              MEANING               |
	//	|                               |                                    |
	//	+-------------------------------+------------------------------------+
	//	+-------------------------------+------------------------------------+
	//	| SCARD_LEAVE_CARD 0x00000000   | Do not do anything.                |
	//	+-------------------------------+------------------------------------+
	//	| SCARD_RESET_CARD 0x00000001   | Reset the smart card.              |
	//	+-------------------------------+------------------------------------+
	//	| SCARD_UNPOWER_CARD 0x00000002 | Turn off and reset the smart card. |
	//	+-------------------------------+------------------------------------+
	Initialization uint32 `idl:"name:dwInitialization" json:"initialization"`
}

ReconnectCall structure represents Reconnect_Call RPC structure.

The Reconnect_Call structure is used to reopen a connection to the smart card associated with a valid context. For more information, see section 3.1.4.36.

func (*ReconnectCall) MarshalNDR 

func (o *ReconnectCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReconnectCall) UnmarshalNDR 

func (o *ReconnectCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type ReconnectReturn 

type ReconnectReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// dwActiveProtocol:  A flag that indicates the established active protocol. For more
	// information on acceptable values, see section 2.2.5 .
	ActiveProtocol uint32 `idl:"name:dwActiveProtocol" json:"active_protocol"`
}

ReconnectReturn structure represents Reconnect_Return RPC structure.

The Reconnect_Return structure is used to obtain return information from a Reconnect call (for more information, see section 3.1.4.36).

func (*ReconnectReturn) MarshalNDR 

func (o *ReconnectReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*ReconnectReturn) UnmarshalNDR 

func (o *ReconnectReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SetAttributeCall 

type SetAttributeCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// dwAttrId:  The identifier of the attribute to set. The values are write-only. For
	// more information on possible values, see [PCSC3] section 3.1.2.
	AttributeID uint32 `idl:"name:dwAttrId" json:"attribute_id"`
	// cbAttrLen:  The size, in bytes, of the data corresponding to the pbAttr field.
	AttributeLength uint32 `idl:"name:cbAttrLen" json:"attribute_length"`
	// pbAttr:  A buffer that contains the attribute whose identifier is supplied in the
	// dwAttrId field. The format is specific to the value being set.
	Attribute []byte `idl:"name:pbAttr;size_is:(cbAttrLen)" json:"attribute"`
}

SetAttributeCall structure represents SetAttrib_Call RPC structure.

The SetAttrib_Call structure allows users to set smart card reader attributes.

func (*SetAttributeCall) MarshalNDR 

func (o *SetAttributeCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SetAttributeCall) UnmarshalNDR 

func (o *SetAttributeCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type SmartCardIORequest 

type SmartCardIORequest struct {
	// dwProtocol:  The protocol in use. Possible values are specified in section 2.2.5.
	Protocol uint32 `idl:"name:dwProtocol" json:"protocol"`
	// cbExtraBytes:  The number of bytes in the pbExtraBytes field.
	ExtraBytesLength uint32 `idl:"name:cbExtraBytes" json:"extra_bytes_length"`
	// pbExtraBytes:  Request data.
	ExtraBytes []byte `idl:"name:pbExtraBytes;size_is:(cbExtraBytes);pointer:unique" json:"extra_bytes"`
}

SmartCardIORequest structure represents SCardIO_Request RPC structure.

The SCardIO_Request structure represents the data to be prepended to a Transmit command (for more information, see section 3.1.4.35).

func (*SmartCardIORequest) MarshalNDR 

func (o *SmartCardIORequest) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*SmartCardIORequest) UnmarshalNDR 

func (o *SmartCardIORequest) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type StateCall 

type StateCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// fpbAtrIsNULL:  A Boolean value specifying whether the caller wants to retrieve the
	// length of the data. Set to FALSE (0x00000000) to allow the data to be returned. Set
	// to TRUE (0x00000001), and only the length of the data will be returned. SHOULD be
	// set to TRUE if cbAtrLen is set to SCARD_AUTOALLOCATE (0xFFFFFFFF).
	//
	//	+-------+------------+
	//	|       |            |
	//	| NAME  |   VALUE    |
	//	|       |            |
	//	+-------+------------+
	//	+-------+------------+
	//	| FALSE | 0x00000000 |
	//	+-------+------------+
	//	| TRUE  | 0x00000001 |
	//	+-------+------------+
	AttributeIsNull int32 `idl:"name:fpbAtrIsNULL" json:"attribute_is_null"`
	// cbAtrLen:  The length of the buffer specified on the TS server side. If cbAtrLen
	// is set to SCARD_AUTOALLOCATE with a value of 0xFFFFFFFF, an array of any length can
	// be returned. Otherwise, the returned array MUST NOT exceed cbAtrLen bytes in length.
	// When the array to be returned exceeds cbAtrLen bytes in length, State_Return.ReturnCode
	// MUST be set to SCARD_E_INSUFFICIENT_BUFFER (0x80100008). Also, cbAtrLen is ignored
	// if fpbAtrIsNULL is set to TRUE (0x00000001). If fpbAtrIsNULL is set to FALSE (0x00000000)
	// but cbAtrLen is set to 0x00000000, then the call MUST succeed, State_Return.cbAtrLen
	// MUST be set to the length of the data in bytes, and State_Return.rgAtr MUST be set
	// to NULL.
	AttributeLength uint32 `idl:"name:cbAtrLen" json:"attribute_length"`
}

StateCall structure represents State_Call RPC structure.

The State_Call structure defines parameters to the State call (as specified in section 3.1.4.40) for querying the contents of a smart card reader.

func (*StateCall) MarshalNDR 

func (o *StateCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*StateCall) UnmarshalNDR 

func (o *StateCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type StateReturn 

type StateReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// dwState:  The current state of the smart card in the Reader. Possible values are
	// specified in section 2.2.4.
	State uint32 `idl:"name:dwState" json:"state"`
	// dwProtocol:  The current protocol, if any. Possible values are specified in section
	// 2.2.5.
	Protocol uint32 `idl:"name:dwProtocol" json:"protocol"`
	// cbAtrLen:  The number of bytes in the rgAtr field.
	AttributeLength uint32 `idl:"name:cbAtrLen" json:"attribute_length"`
	// rgAtr:  A pointer to a buffer that receives the ATR string from the currently inserted
	// card, if available.
	Attribute []byte `idl:"name:rgAtr;size_is:(cbAtrLen);pointer:unique" json:"attribute"`
}

StateReturn structure represents State_Return RPC structure.

The State_Return structure defines return information about the state of the smart card reader (for more information, see section 3.1.4.40).

func (*StateReturn) MarshalNDR 

func (o *StateReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*StateReturn) UnmarshalNDR 

func (o *StateReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type StatusCall 

type StatusCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// fmszReaderNamesIsNULL:  A Boolean value specifying whether the caller wants to retrieve
	// the length of the data. Set to FALSE (0x00000000) to allow the data to be returned.
	// Set to TRUE (0x00000001), and only the length of the data will be returned. Also,
	// cchReaderLen is ignored if this value is TRUE (0x00000001).
	//
	//	+-------+------------+
	//	|       |            |
	//	| NAME  |   VALUE    |
	//	|       |            |
	//	+-------+------------+
	//	+-------+------------+
	//	| FALSE | 0x00000000 |
	//	+-------+------------+
	//	| TRUE  | 0x00000001 |
	//	+-------+------------+
	ReaderNamesIsNull int32 `idl:"name:fmszReaderNamesIsNULL" json:"reader_names_is_null"`
	// cchReaderLen:  The length of the string buffer specified on the TS server side. If
	// cchReaderLen is set to SCARD_AUTOALLOCATE with a value of 0xFFFFFFFF, a string of
	// any length can be returned. Otherwise, the returned string MUST NOT exceed cchReaderLen
	// characters in length, including any null characters. When the string to be returned
	// exceeds cchReaderLen characters in length, including any null characters, Status_Return.ReturnCode
	// MUST be set to SCARD_E_INSUFFICIENT_BUFFER (0x80100008). The cchReaderLen field MUST
	// be ignored if fmszReaderNamesIsNULL is TRUE (0x00000001). Also, if fmszReaderNamesIsNULL
	// is set to FALSE (0x00000000) but cchReaderLen is set to 0x00000000, then the call
	// MUST succeed, Status_Return.cbAtrLen MUST be set to the length of the data in bytes,
	// and Status_Return.pbAtr MUST be set to NULL.
	ReaderLength uint32 `idl:"name:cchReaderLen" json:"reader_length"`
	// cbAtrLen:  Unused. MUST be ignored upon receipt.
	AttributeLength uint32 `idl:"name:cbAtrLen" json:"attribute_length"`
}

StatusCall structure represents Status_Call RPC structure.

Status_Call obtains the status of a connection for a valid smart card reader handle.

func (*StatusCall) MarshalNDR 

func (o *StatusCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*StatusCall) UnmarshalNDR 

func (o *StatusCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type StatusReturn 

type StatusReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// cBytes:  The number of bytes in the mszReaderNames field.
	BytesCount uint32 `idl:"name:cBytes" json:"bytes_count"`
	// mszReaderNames:  A multistring containing the names that the reader is known by.
	// The value of this is dependent on the context (IOCTL) that it is used.
	//
	//	+--------------------------------+---------------------+
	//	|                                |                     |
	//	|             VALUE              |       MEANING       |
	//	|                                |                     |
	//	+--------------------------------+---------------------+
	//	+--------------------------------+---------------------+
	//	| SCARD_IOCTL_STATUSA 0x000900C8 | ASCII multistring   |
	//	+--------------------------------+---------------------+
	//	| SCARD_IOCTL_STATUSW 0x000900CC | Unicode multistring |
	//	+--------------------------------+---------------------+
	ReaderNames []byte `idl:"name:mszReaderNames;size_is:(cBytes);pointer:unique" json:"reader_names"`
	// dwState:  The current state of the smart card in the reader. Possible values are
	// specified in section 2.2.4.
	State uint32 `idl:"name:dwState" json:"state"`
	// dwProtocol:  The current protocol, if any. Possible values are specified in section
	// 2.2.5.
	Protocol uint32 `idl:"name:dwProtocol" json:"protocol"`
	// pbAtr:  A pointer to a buffer that receives the ATR string from the currently inserted
	// card, if available.
	Attribute []byte `idl:"name:pbAtr" json:"attribute"`
	// cbAtrLen:  The number of bytes in the ATR string.
	AttributeLength uint32 `idl:"name:cbAtrLen" json:"attribute_length"`
}

StatusReturn structure represents Status_Return RPC structure.

The Status_Return structure defines return information about the status of the smart card reader (for more information, see sections 3.1.4.33 and 3.1.4.34).

func (*StatusReturn) MarshalNDR 

func (o *StatusReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*StatusReturn) UnmarshalNDR 

func (o *StatusReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TransmitCall 

type TransmitCall struct {
	// hCard:  A handle, as specified in section 2.2.1.2.
	Card *ReaderSmartCardHandle `idl:"name:hCard" json:"card"`
	// ioSendPci:  A packet specifying input header information as specified in section
	// 2.2.1.8.
	SendPCI *SmartCardIORequest `idl:"name:ioSendPci" json:"send_pci"`
	// cbSendLength:  The length, in bytes, of the pbSendBuffer field.
	SendLength uint32 `idl:"name:cbSendLength" json:"send_length"`
	// pbSendBuffer:  The data to be written to the card. The format of the data is specific
	// to an individual card. For more information about data formats, see [ISO/IEC-7816-4]
	// sections 5 through 7.
	SendBuffer []byte `idl:"name:pbSendBuffer;size_is:(cbSendLength)" json:"send_buffer"`
	// pioRecvPci:  If non-NULL, this field is an SCardIO_Request packet that is set up
	// in the same way as the ioSendPci field and passed as the pioRecvPci parameter of
	// the Transmit call. If the value of this is NULL, the caller is not requesting the
	// pioRecvPci value to be returned.
	RecvPCI *SmartCardIORequest `idl:"name:pioRecvPci;pointer:unique" json:"recv_pci"`
	// fpbRecvBufferIsNULL:  A Boolean value specifying whether the caller wants to retrieve
	// the length of the data. MUST be set to TRUE (0x00000001) if the caller wants only
	// to retrieve the length of the data; otherwise, it MUST be set to FALSE (0x00000000).
	//
	//	+-------+------------+
	//	|       |            |
	//	| NAME  |   VALUE    |
	//	|       |            |
	//	+-------+------------+
	//	+-------+------------+
	//	| FALSE | 0x00000000 |
	//	+-------+------------+
	//	| TRUE  | 0x00000001 |
	//	+-------+------------+
	RecvBufferIsNull int32 `idl:"name:fpbRecvBufferIsNULL" json:"recv_buffer_is_null"`
	// cbRecvLength:  The maximum size of the buffer to be returned. MUST be ignored if
	// fpbRecvBufferIsNULL is set to TRUE (0x00000001).
	RecvLength uint32 `idl:"name:cbRecvLength" json:"recv_length"`
}

TransmitCall structure represents Transmit_Call RPC structure.

The Transmit_Call structure is used to send data to the smart card associated with a valid context.

func (*TransmitCall) MarshalNDR 

func (o *TransmitCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*TransmitCall) UnmarshalNDR 

func (o *TransmitCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TransmitReturn 

type TransmitReturn struct {
	// ReturnCode:  HRESULT or Win32 Error code. Zero indicates success; any other value
	// indicates failure.
	ReturnCode int32 `idl:"name:ReturnCode" json:"return_code"`
	// pioRecvPci:  The protocol header structure for the instruction, followed by a buffer
	// in which to receive any returned protocol control information (PCI) that is specific
	// to the protocol in use. If this field is NULL, a protocol header MUST NOT be returned.
	RecvPCI *SmartCardIORequest `idl:"name:pioRecvPci;pointer:unique" json:"recv_pci"`
	// cbRecvLength:  The size, in bytes, of the pbRecvBuffer field.
	RecvLength uint32 `idl:"name:cbRecvLength" json:"recv_length"`
	// pbRecvBuffer:  The data returned from the card.
	RecvBuffer []byte `idl:"name:pbRecvBuffer;size_is:(cbRecvLength);pointer:unique" json:"recv_buffer"`
}

TransmitReturn structure represents Transmit_Return RPC structure.

The Transmit_Return structure defines return information from a smart card after a Transmit call (for more information, see section 3.1.4.35).

func (*TransmitReturn) MarshalNDR 

func (o *TransmitReturn) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*TransmitReturn) UnmarshalNDR 

func (o *TransmitReturn) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type TypeSmartCardPackClient 

type TypeSmartCardPackClient interface {

	// AlterContext alters the client context.
	AlterContext(context.Context, ...dcerpc.Option) error
}

type_scard_pack interface.

func NewTypeSmartCardPackClient 

func NewTypeSmartCardPackClient(ctx context.Context, cc dcerpc.Conn, opts ...dcerpc.Option) (TypeSmartCardPackClient, error)

type TypeSmartCardPackServer 

type TypeSmartCardPackServer interface {
}

type_scard_pack server interface.

type WriteCacheACall 

type WriteCacheACall struct {
	// szLookupName:  An ASCII string containing the lookup name.
	LookupName string `idl:"name:szLookupName;string" json:"lookup_name"`
	// Common:  Additional parameters for the Write Cache call (for more information, see
	// section 3.1.4.44), as specified in section 2.2.1.10.
	Common *WriteCacheCommon `idl:"name:Common" json:"common"`
}

WriteCacheACall structure represents WriteCacheA_Call RPC structure.

The WriteCacheA_Call structure is used to write the card and reader information to the cache.

func (*WriteCacheACall) MarshalNDR 

func (o *WriteCacheACall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*WriteCacheACall) UnmarshalNDR 

func (o *WriteCacheACall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type WriteCacheCommon 

type WriteCacheCommon struct {
	// Context:  A valid context, as specified in section 2.2.1.1.
	Context *ReaderSmartCardContext `idl:"name:Context" json:"context"`
	// CardIdentifier:  A UUID that identifies the smart card with which the data SHOULD
	// be stored. CardIdentifier MUST be a unique value per the smart card.
	CardID *dtyp.UUID `idl:"name:CardIdentifier" json:"card_id"`
	// FreshnessCounter:  A value specifying the current revision of the data.
	FreshnessCounter uint32 `idl:"name:FreshnessCounter" json:"freshness_counter"`
	// cbDataLen:  The number of bytes in the pbData field.
	DataLength uint32 `idl:"name:cbDataLen" json:"data_length"`
	// pbData:  cbDataLen bytes of data to be stored.
	Data []byte `idl:"name:pbData;size_is:(cbDataLen);pointer:unique" json:"data"`
}

WriteCacheCommon structure represents WriteCache_Common RPC structure.

The WriteCache_Common structure contains information common between the WriteCacheA_Call and WriteCacheW_Call structures.

func (*WriteCacheCommon) MarshalNDR 

func (o *WriteCacheCommon) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*WriteCacheCommon) UnmarshalNDR 

func (o *WriteCacheCommon) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

type WriteCacheWCall 

type WriteCacheWCall struct {
	// szLookupName:  An Unicode string containing the lookup name.
	LookupName string `idl:"name:szLookupName;string" json:"lookup_name"`
	// Common:  Additional parameters for the Write Cache call (for more information, see
	// section 2.2.1.10.
	Common *WriteCacheCommon `idl:"name:Common" json:"common"`
}

WriteCacheWCall structure represents WriteCacheW_Call RPC structure.

The WriteCacheW_Call structure is used to write the card and reader information to the cache.

func (*WriteCacheWCall) MarshalNDR 

func (o *WriteCacheWCall) MarshalNDR(ctx context.Context, w ndr.Writer) error

func (*WriteCacheWCall) UnmarshalNDR 

func (o *WriteCacheWCall) UnmarshalNDR(ctx context.Context, w ndr.Reader) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.