fax

package
v1.0.5 Latest Latest
Warning

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

 Go to latest Published: Oct 29, 2024 License: MIT Imports: 10 Imported by: 0

Documentation

Overview

The fax package implements the FAX client protocol.

Introduction

The Fax Server and Client Remote Protocol Specification defines a protocol that is referred to as the Fax Server and Client Remote Protocol. This is a client/server protocol based on remote procedure call (RPC) that is used to send faxes and manage the fax server and its queues.

Overview

The Fax Server and Client Remote Protocol manages and sends faxes, manages the fax server and its queues, and allows fax clients to act as RPC servers so that they can accept status notifications from fax servers acting as clients.

Index

Constants

This section is empty.

Variables

View Source 
var CopyBufferSize = 16384

CopyBufferSize represents the RPC_COPY_BUFFER_SIZE RPC constant

View Source 
var (
	// import guard
	GoPackage = "fax"
)
View Source 
var MaxDevicesInGroup = 1000

MaxDevicesInGroup represents the FAX_MAX_DEVICES_IN_GROUP RPC constant

View Source 
var MaxRPCBuffer = 1048576

MaxRPCBuffer represents the FAX_MAX_RPC_BUFFER RPC constant

View Source 
var MaxRecipients = 10000

MaxRecipients represents the FAX_MAX_RECIPIENTS RPC constant

Functions

This section is empty.

Types

type ActivityLoggingConfigW 

type ActivityLoggingConfigW struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the size of this
	// structure, in bytes. This value MUST be 16 bytes or 28 bytes. When filled in on a
	// 32-bit implementation, this value SHOULD be 16 bytes. When filled in on a 64-bit
	// implementation, this value SHOULD be 28 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// bLogIncoming: A Boolean flag that indicates whether incoming fax activities are logged.
	LogIncoming bool `idl:"name:bLogIncoming" json:"log_incoming"`
	// bLogOutgoing: A Boolean flag that indicates whether outgoing fax activities are logged.
	LogOutgoing bool `idl:"name:bLogOutgoing" json:"log_outgoing"`
	// lpwstrDBPath: A pointer to a null-terminated character string that holds the directory
	// on the server where the activity logging database files reside. <5>
	DBPath string `idl:"name:lpwstrDBPath;string" json:"db_path"`
}

ActivityLoggingConfigW structure represents FAX_ACTIVITY_LOGGING_CONFIGW RPC structure.

The FAX_ACTIVITY_LOGGING_CONFIGW structure is used as an input parameter for the FAX_SetActivityLoggingConfiguration (section 3.1.4.1.74) call.

func (*ActivityLoggingConfigW) MarshalNDR 

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

func (*ActivityLoggingConfigW) UnmarshalNDR 

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

type CompletionEvent 

type CompletionEvent struct {
	// SizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size of
	// the structure, in bytes. This value MUST be 24 bytes.
	StructureSize uint32 `idl:"name:SizeOfStruct" json:"structure_size"`
	// TimeStamp: Specifies a FILETIME ([MS-DTYP] section 2.3.3) structure that contains
	// the time at which the fax server generated the event.
	Timestamp *dtyp.Filetime `idl:"name:TimeStamp" json:"timestamp"`
	// DeviceId: Specifies a DWORD variable that indicates the line identifier for the fax
	// device (port) of interest.
	DeviceID uint32 `idl:"name:DeviceId" json:"device_id"`
	// EventId: Specifies a DWORD variable that identifies the current asynchronous event
	// that occurred within the fax server. The following table lists the possible events
	// and their meanings.
	//
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	|                                   |                                                                                  |
	//	|            VALUE/CODE             |                                     MEANING                                      |
	//	|                                   |                                                                                  |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_DIALING 0x00000001            | The sending device is dialing a fax number.                                      |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_SENDING 0x00000002            | The sending device is transmitting a page of fax data.                           |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_RECEIVING 0x00000003          | The receiving device is receiving a page of fax data.                            |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_COMPLETED 0x00000004          | The device has completed a fax transmission call.                                |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_BUSY 0x00000005               | The sending device has encountered a busy signal.                                |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_NO_ANSWER 0x00000006          | The receiving device does not answer.                                            |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_BAD_ADDRESS 0x00000007        | The sending device cannot complete the call because the fax number is invalid.   |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_NO_DIAL_TONE 0x00000008       | The sending device cannot complete the call because it does not detect a dial    |
	//	|                                   | tone.                                                                            |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_DISCONNECTED 0x00000009       | The device cannot complete the call because a fax device was disconnected or     |
	//	|                                   | because the fax call itself was disconnected.                                    |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_FATAL_ERROR 0x0000000A        | The device encountered a fatal protocol error.                                   |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_NOT_FAX_CALL 0x0000000B       | The modem device received a data call or a voice call.                           |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_CALL_DELAYED 0x0000000C       | The sending device received a busy signal multiple times. The device cannot      |
	//	|                                   | retry the call because dialing restrictions exist (some countries and regions    |
	//	|                                   | restrict the number of retry attempts when a number is busy).                    |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_CALL_BLACKLISTED 0x0000000D   | The device cannot complete the call because the telephone number is blocked or   |
	//	|                                   | reserved; numbers such as 911 are blocked.                                       |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_RINGING 0x0000000E            | The receiving device is ringing.                                                 |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_ABORTING 0x0000000F           | The device is aborting a fax job.                                                |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_ROUTING 0x00000010            | The receiving device is routing a received fax document.                         |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_MODEM_POWERED_ON 0x000000011  | The modem device was turned on.                                                  |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_MODEM_POWERED_OFF 0x000000012 | The modem device was turned off.                                                 |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_IDLE 0x000000013              | The device is idle.                                                              |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_FAXSVC_ENDED 0x000000014      | The fax service has terminated. For more information, see the following Remarks  |
	//	|                                   | section.                                                                         |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_ANSWERED 0x000000015          | The receiving device answered a new call.                                        |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_JOB_QUEUED 0x000000016        | The fax job has been queued.                                                     |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_DELETED 0x00000017            | The fax job has been processed. The job identifier for the job is no longer      |
	//	|                                   | valid.                                                                           |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_INITIALIZING 0x00000018       | The modem device is being initialized.                                           |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_LINE_UNAVAILABLE 0x00000019   | The device cannot complete the call because the requested line is unavailable.   |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_HANDLED 0x0000001A            | The fax job has been processed.                                                  |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_FAXSVC_STARTED 0x0000001B     | The fax service has started. For more information, see the following Remarks     |
	//	|                                   | section. Interchangeable with FEI_NEVENTS.                                       |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	//	| FEI_NEVENTS 0x0000001B            | The total number of fax events received. For more information, see the following |
	//	|                                   | Remarks section. Interchangeable with FEI_FAXSVC_STARTED.                        |
	//	+-----------------------------------+----------------------------------------------------------------------------------+
	EventID uint32 `idl:"name:EventId" json:"event_id"`
	// JobId: Specifies a unique number that identifies the fax job of interest. If this
	// member is equal to the value 0xffffffff, it indicates an inactive fax job. Note that
	// this number is not a print spooler identification number.
	//
	// After a fax client application receives the FEI_FAXSVC_ENDED message from the fax
	// service, it will no longer receive fax events. To resume receiving fax events, the
	// application MUST call the FaxInitializeEventQueue function again when the fax service
	// restarts. The application can determine whether the fax service is running by using
	// the service control manager.
	//
	// If the application receives events by means of notification messages, it can use
	// the FEI_NEVENTS event. If the message is between the application's base window message
	// and the base window message + FEI_NEVENTS, then the application can process the message
	// as a fax window message. An application specifies the base window message by using
	// the MessageStart parameter in the FaxInitializeEventQueue function; the base window
	// message MUST be greater than the WM_USER message.
	JobID uint32 `idl:"name:JobId" json:"job_id"`
}

CompletionEvent structure represents FAX_EVENT RPC structure.

The FAX_EVENT structure represents the contents of an input/output (I/O) completion packet. The fax server sends the completion packet to notify a fax client application about an asynchronous fax server event.

func (*CompletionEvent) MarshalNDR 

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

func (*CompletionEvent) UnmarshalNDR 

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

type ConfigOption 

type ConfigOption uint16

ConfigOption type represents FAX_ENUM_CONFIG_OPTION RPC enumeration.

The FAX_ENUM_CONFIG_OPTION enumeration identifies the configuration option to be returned by the FAX_GetConfigOption (section 3.1.4.1.35) method. 

var (
	// FAX_CONFIG_OPTION_ALLOW_PERSONAL_CP: Represents whether the server allows personal
	// cover pages.
	ConfigOptionAllowPersonalCreatePartition ConfigOption = 0
	// FAX_CONFIG_OPTION_QUEUE_STATE: Corresponds to the state of the queue in Queue State.
	ConfigOptionQueueState ConfigOption = 1
	// FAX_CONFIG_OPTION_ALLOWED_RECEIPTS: Corresponds to the type of receipts the server
	// is configured to send.
	ConfigOptionAllowedReceipts ConfigOption = 2
	// FAX_CONFIG_OPTION_INCOMING_FAXES_PUBLIC: Corresponds to the viewing permissions of
	// incoming faxes.
	ConfigOptionIncomingFaxesPublic ConfigOption = 3
)

func (ConfigOption) String 

func (o ConfigOption) String() string

type ConfigW 

type ConfigW struct {
	// SizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size of
	// the structure, in bytes. This value MUST be either 52 or 64 bytes. When filled in
	// on a 32-bit implementation, this value SHOULD be 52 bytes. When filled in on a 64-bit
	// implementation, this value SHOULD be 64 bytes.
	StructureSize uint32 `idl:"name:SizeOfStruct" json:"structure_size"`
	// Retries: A DWORD variable that contains the value of the fax transmission retries
	// fax server configuration setting (section 3.1.1).
	Retries uint32 `idl:"name:Retries" json:"retries"`
	// RetryDelay: A DWORD variable that contains the value of the fax transmission retry
	// delay fax server configuration setting.
	RetryDelay uint32 `idl:"name:RetryDelay" json:"retry_delay"`
	// DirtyDays: A DWORD variable that contains the value of the dirty days fax server
	// configuration setting.
	DirtyDays uint32 `idl:"name:DirtyDays" json:"dirty_days"`
	// Branding: A Boolean flag that specifies whether the fax server generates a brand
	// (banner) at the top of outgoing fax transmissions. If this member is TRUE, the fax
	// server generates a brand that contains transmission-related information like the
	// transmitting subscriber identifier, date, time, and page count. This flag configures
	// the Branding fax server configuration setting.
	Branding bool `idl:"name:Branding" json:"branding"`
	// UseDeviceTsid: A Boolean flag that specifies whether the fax server uses the device's
	// transmitting subscriber identifier instead of the value specified in the Tsid member
	// of the FAX_JOB_PARAMW (section 2.2.13) structure. If this member is TRUE, the server
	// uses the device's transmitting subscriber identifier. This flag configures the "use
	// of the device's TSID" fax server configuration setting.
	UseDeviceTSID bool `idl:"name:UseDeviceTsid" json:"use_device_tsid"`
	// ServerCp: A Boolean flag that specifies whether fax client applications can include
	// a user-designed cover page template with the fax transmission. If this member is
	// TRUE, the client MUST use a common cover page template stored on the fax server.
	// If this member is FALSE, the client can use a personal cover page template. This
	// flag configures the personal cover page support fax server configuration setting.
	ServerCreatePartition bool `idl:"name:ServerCp" json:"server_create_partition"`
	// PauseServerQueue: A Boolean flag that specifies whether the fax server has paused
	// the outgoing fax queue. If this member is TRUE, the outgoing fax queue is paused
	// and the Queue State (section 3.1.1) is set to FAX_OUTBOX_PAUSED (0x00000004). If
	// this field is FALSE, the outgoing fax queue is not paused, and the Queue State is
	// either 0x00000000 or FAX_OUTBOX_BLOCKED (0x00000002).
	PauseServerQueue bool `idl:"name:PauseServerQueue" json:"pause_server_queue"`
	// StartCheapTime: Contains a FAX_TIME (section 2.2.61) structure that indicates the
	// hour and minute values of the current start cheap time fax server configuration setting.
	StartCheapTime *Time `idl:"name:StartCheapTime" json:"start_cheap_time"`
	// StopCheapTime: Contains a FAX_TIME that indicates the hour and minute values of the
	// current stop cheap time fax server configuration setting.
	StopCheapTime *Time `idl:"name:StopCheapTime" json:"stop_cheap_time"`
	// ArchiveOutgoingFaxes: A Boolean flag that specifies whether the fax server archives
	// fax transmissions. If this member is TRUE, the server archives transmissions in the
	// directory specified by the ArchiveDirectory member. This flag configures the Archive
	// Enabled fax server configuration setting.<6>
	ArchiveOutgoingFaxes bool `idl:"name:ArchiveOutgoingFaxes" json:"archive_outgoing_faxes"`
	// ArchiveDirectory: A pointer to a constant, null-terminated character string that
	// holds the fully qualified path of the Fax Archive Folder fax server configuration
	// setting. The path can be a UNC path or a path that begins with a drive letter. The
	// fax server ignores this member if the ArchiveOutgoingFaxes member is FALSE. This
	// member can be NULL if the ArchiveOutgoingFaxes member is FALSE.<7>
	ArchiveDirectory string `idl:"name:ArchiveDirectory;string" json:"archive_directory"`
	// ProfileName: Reserved (not used) when this structure is used for FAX_SetConfiguration
	// (section 3.1.4.1.76).
	ProfileName string `idl:"name:ProfileName;string" json:"profile_name"`
}

ConfigW structure represents FAX_CONFIGURATIONW RPC structure.

The _FAX_CONFIGURATIONW data type is the custom-marshaled variant of the FAX_CONFIGURATIONW (section 2.2.28) structure. This data type is used as an output parameter (as a byte array) for FAX_GetConfiguration (section 3.1.4.1.36) and FaxObs_GetConfiguration (section 3.1.4.2.24) to return the current fax server configuration settings. Along with the FAX_GENERAL_CONFIG (section 2.2.31) data structure, this data structure describes the general configuration of the fax server.

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (52 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

The FAX_CONFIGURATIONW structure is used as an input parameter for the FAX_SetConfiguration (section 3.1.4.1.76) and FaxObs_SetConfiguration (section 3.1.4.2.25) methods to change the current fax server configuration settings. Along with the FAX_GENERAL_CONFIG (section 2.2.31) structure, this data structure describes the general configuration of the fax server.

func (*ConfigW) MarshalNDR 

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

func (*ConfigW) UnmarshalNDR 

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

type Copy 

type Copy dcetypes.ContextHandle

Copy structure represents RPC_FAX_COPY_HANDLE RPC structure.

func (*Copy) ContextHandle 

func (o *Copy) ContextHandle() *dcetypes.ContextHandle

func (*Copy) MarshalNDR 

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

func (*Copy) UnmarshalNDR 

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

type CoverPageInfoExW 

type CoverPageInfoExW struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size
	// of the structure, in bytes. This value MUST be 24 or 40 bytes. When filled in on
	// a 32-bit implementation, this value SHOULD be 24 bytes. When filled in on a 64-bit
	// implementation, this value SHOULD be 40 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// dwCoverPageFormat: A DWORD that indicates the format of the cover page template.
	// This MUST be one of the values defined in FAX_ENUM_COVERPAGE_FORMATS (section 2.2.78)
	// enumeration. The required file format for the cover page template is described in
	// FAX_SendDocumentEx (section 3.1.4.1.73) method.
	CoverPageFormat uint32 `idl:"name:dwCoverPageFormat" json:"cover_page_format"`
	// lpwstrCoverPageFileName: A pointer to a null-terminated character string that holds
	// the file name of the cover page template. This file name SHOULD NOT include any path
	// separators. If bServerBased is FALSE, the file extension MUST be ".cov", and except
	// for the terminating null character, the character string MUST contain only characters
	// representing valid hexadecimal digits: "0123456789abcdefABCDEF". If bServerBased
	// is TRUE the file extension SHOULD be ".cov". The cover page file MUST be present
	// in the fax server queue directory when the FAX_SendDocumentEx call is made. If no
	// cover-page information is available, this pointer MUST be NULL.
	CoverPageFileName string `idl:"name:lpwstrCoverPageFileName;string" json:"cover_page_file_name"`
	// bServerBased: A Boolean that indicates whether the cover page template specified
	// by the lpwstrCoverPageFileName parameter is a new personal cover page template (when
	// set to FALSE)  or a server-based cover page template (when set to TRUE). For more
	// details on the semantics of TRUE and FALSE, see FAX_SendDocumentEx.
	ServerBased bool `idl:"name:bServerBased" json:"server_based"`
	// lpwstrNote: A pointer to a null-terminated character string that holds the content
	// for the note field of the cover page.
	Note string `idl:"name:lpwstrNote;string" json:"note"`
	// lpwstrSubject: A pointer to a null-terminated character string that holds the content
	// for the subject field.
	Subject string `idl:"name:lpwstrSubject;string" json:"subject"`
}

CoverPageInfoExW structure represents FAX_COVERPAGE_INFO_EXW RPC structure.

The FAX_COVERPAGE_INFO_EXW structure is used as an argument for the FAX_SendDocumentEx (section 3.1.4.1.73) call that specifies information about the fax cover page used when sending a fax.

func (*CoverPageInfoExW) MarshalNDR 

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

func (*CoverPageInfoExW) UnmarshalNDR 

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

type DeviceReceiveMode 

type DeviceReceiveMode uint16

DeviceReceiveMode type represents FAX_ENUM_DEVICE_RECEIVE_MODE RPC enumeration.

The FAX_ENUM_DEVICE_RECEIVE_MODE enumeration constants describe the receive mode for a fax device. 

var (
	// FAX_DEVICE_RECEIVE_MODE_OFF: Do not answer incoming calls.
	DeviceReceiveModeOff DeviceReceiveMode = 0
	// FAX_DEVICE_RECEIVE_MODE_AUTO: Automatically answer incoming calls after the specified
	// number of rings.
	DeviceReceiveModeAuto DeviceReceiveMode = 1
	// FAX_DEVICE_RECEIVE_MODE_MANUAL: Manually answer incoming calls.
	DeviceReceiveModeManual DeviceReceiveMode = 2
)

func (DeviceReceiveMode) String 

func (o DeviceReceiveMode) String() string

type Event 

type Event dcetypes.ContextHandle

Event structure represents RPC_FAX_EVENT_HANDLE RPC structure.

func (*Event) ContextHandle 

func (o *Event) ContextHandle() *dcetypes.ContextHandle

func (*Event) MarshalNDR 

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

func (*Event) UnmarshalNDR 

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

type EventEx 

type EventEx dcetypes.ContextHandle

EventEx structure represents RPC_FAX_EVENT_EX_HANDLE RPC structure.

func (*EventEx) ContextHandle 

func (o *EventEx) ContextHandle() *dcetypes.ContextHandle

func (*EventEx) MarshalNDR 

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

func (*EventEx) UnmarshalNDR 

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

type Fax 

type Fax dcetypes.ContextHandle

Fax structure represents RPC_FAX_HANDLE RPC structure.

func (*Fax) ContextHandle 

func (o *Fax) ContextHandle() *dcetypes.ContextHandle

func (*Fax) MarshalNDR 

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

func (*Fax) UnmarshalNDR 

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

type GlobalRoutingInfoW 

type GlobalRoutingInfoW struct {
	// SizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) that holds the total size of the
	// structure, in bytes. This value MUST be 28 bytes or 48 bytes. When filled in on a
	// 32-bit implementation, this value SHOULD be 28 bytes. When filled in on a 64-bit
	// implementation, this value SHOULD be 48 bytes.
	StructureSize uint32 `idl:"name:SizeOfStruct" json:"structure_size"`
	// Priority: A DWORD variable that holds the priority of the fax routing method. The
	// priority determines the relative order in which the fax service calls the fax routing
	// methods when the service receives a fax document. Values for this member MUST be
	// 1 through the maximum DWORD value (0xFFFFFFFF or 4,294,967,295), where 1 is the highest
	// priority.
	Priority uint32 `idl:"name:Priority" json:"priority"`
	// Guid: A pointer to a constant, null-terminated character string that holds the GUID
	// that uniquely identifies the fax routing method of interest.
	GUID string `idl:"name:Guid;string" json:"guid"`
	// FriendlyName: A pointer to a constant, null-terminated character string that holds
	// the user-friendly name to display for the fax routing method.
	FriendlyName string `idl:"name:FriendlyName;string" json:"friendly_name"`
	// FunctionName: A pointer to a null-terminated character string that holds the name
	// of the function that executes the specified fax routing method.
	FunctionName string `idl:"name:FunctionName;string" json:"function_name"`
	// ExtensionImageName: A pointer to a constant, null-terminated character string that
	// holds the name of the fax routing extensions that implements the fax routing method.
	ExtensionImageName string `idl:"name:ExtensionImageName;string" json:"extension_image_name"`
	// ExtensionFriendlyName: A pointer to a constant, null-terminated character string
	// that holds the user-friendly name to display for the fax routing extensions that
	// implement the fax routing method.
	ExtensionFriendlyName string `idl:"name:ExtensionFriendlyName;string" json:"extension_friendly_name"`
}

GlobalRoutingInfoW structure represents FAX_GLOBAL_ROUTING_INFOW RPC structure.

An array of the FAX_GLOBAL_ROUTING_INFOW structure is used as an input parameter to FAX_SetGlobalRoutingInfo (section 3.1.4.1.81) and FaxObs_SetGlobalRoutingInfo (section 3.1.4.2.23).

The _FAX_GLOBAL_ROUTING_INFOW structure is the custom-marshaled variant of the FAX_GLOBAL_ROUTING_INFOW data structure described in (section 2.2.32). A byte array of this structure is used as an output parameter in FAX_EnumGlobalRoutingInfo (section 3.1.4.1.20) and in FaxObs_EnumGlobalRoutingInfo (section 3.1.4.2.22).

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (28 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*GlobalRoutingInfoW) MarshalNDR 

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

func (*GlobalRoutingInfoW) UnmarshalNDR 

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

type GroupStatus 

type GroupStatus uint16

GroupStatus type represents FAX_ENUM_GROUP_STATUS RPC enumeration.

The FAX_ENUM_GROUP_STATUS enumeration defines status types for outbound routing groups. 

var (
	// FAX_GROUP_STATUS_ALL_DEV_VALID: All the devices in the group are valid and available
	// for sending outgoing faxes.
	GroupStatusAllDevValid GroupStatus = 0
	// FAX_GROUP_STATUS_EMPTY : The group is empty (does not contain any devices), and does
	// not have any routing rules added.
	GroupStatusEmpty GroupStatus = 1
	// FAX_GROUP_STATUS_ALL_DEV_NOT_VALID : All the devices in the group are not available
	// for sending outgoing faxes. Devices could be unavailable if they do not exist or
	// are offline.
	GroupStatusAllDevNotValid GroupStatus = 2
	// FAX_GROUP_STATUS_SOME_DEV_NOT_VALID: Some (but not all) of the devices in the group
	// are not available for sending outgoing faxes. Devices could be unavailable if they
	// do not exist or are offline.
	GroupStatusSomeDevNotValid GroupStatus = 3
)

func (GroupStatus) String 

func (o GroupStatus) String() string

type JobEntry 

type JobEntry struct {
	// SizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) that indicates the size, in bytes,
	// of the FAX_JOB_ENTRY structure. This value MUST be 92 or 136 bytes. When filled in
	// on a 32-bit implementation, this value SHOULD be 92 bytes. When filled in on a 64-bit
	// implementation, this value SHOULD be 136 bytes.
	StructureSize uint32 `idl:"name:SizeOfStruct" json:"structure_size"`
	// JobId: A DWORD that indicates a unique number that identifies the fax jobs of interest.
	// This is the same kind of job identifier number as the JobId parameter for the FAX_SetJob
	// (section 3.1.4.1.82) function.
	JobID uint32 `idl:"name:JobId" json:"job_id"`
	// UserName: A null-terminated character string that contains the name of the fax user
	// account that submitted the fax job, if known; otherwise, a NULL pointer.
	UserName string `idl:"name:UserName" json:"user_name"`
	// JobType: A DWORD that indicates the type of the fax job of interest. This field is
	// one of the following values, which are defined in section 3.1.1.
	//
	//	+------------+----------------------------------+
	//	|            |                                  |
	//	| VALUE/CODE |             MEANING              |
	//	|            |                                  |
	//	+------------+----------------------------------+
	//	+------------+----------------------------------+
	//	| 0x00000000 | The job type is JT_UNKNOWN.      |
	//	+------------+----------------------------------+
	//	| 0x00000001 | The job type is JT_SEND.         |
	//	+------------+----------------------------------+
	//	| 0x00000002 | The job type is JT_RECEIVE.      |
	//	+------------+----------------------------------+
	//	| 0x00000003 | The job type is JT_ROUTING.      |
	//	+------------+----------------------------------+
	//	| 0x00000004 | The job type is JT_FAIL_RECEIVE. |
	//	+------------+----------------------------------+
	JobType uint32 `idl:"name:JobType" json:"job_type"`
	// QueueStatus: A DWORD variable containing a set of bit flags indicating the job status
	// of the fax job identified by the JobId field. This value MUST be a bitwise OR combination
	// of one or more of the Job Status values listed in section 3.1.1.
	QueueStatus uint32 `idl:"name:QueueStatus" json:"queue_status"`
	// Status: A DWORD that specifies the status of the fax device (or port) that received
	// or sent the fax job described by this structure, captured at the time the job information
	// was recorded. This member SHOULD be ignored when this structure is used as an input
	// argument for the FaxObs_SetJob method. This value MUST be one of the following predefined
	// device status codes.
	//
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	|                                 |                                                                                  |
	//	|           VALUE/CODE            |                                     MEANING                                      |
	//	|                                 |                                                                                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_UNKNOWN 0x00000000          | The status of the device is unknown.                                             |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_DIALING 0x20000001          | The device is dialing a fax number.                                              |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_SENDING 0x20000002          | The device is sending a fax document.                                            |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_RECEIVING 0x20000004        | The device is receiving a fax document.                                          |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_COMPLETED 0x20000008        | The device completed sending or receiving a fax transmission.                    |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_HANDLED 0x20000010          | The fax service processed the outbound fax document; the fax service provider    |
	//	|                                 | (FSP) will transmit the fax document.                                            |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_UNAVAILABLE 0x20000020      | The device is not available because it is in use by another application.         |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_BUSY 0x20000040             | The device encountered a busy signal.                                            |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_NO_ANSWER 0x20000080        | The receiving device did not answer the call.                                    |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_BAD_ADDRESS 0x20000100      | The device dialed an invalid fax number.                                         |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_NO_DIAL_TONE 0x20000200     | The sending device cannot complete the call because it does not detect a dial    |
	//	|                                 | tone.                                                                            |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_DISCONNECTED 0x20000400     | The fax call was disconnected by the sender or the caller.                       |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_FATAL_ERROR 0x20000800      | The device has encountered a fatal protocol error.                               |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_NOT_FAX_CALL 0x20001000     | The device received a call that was a data call or a voice call.                 |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_CALL_DELAYED 0x20002000     | The device delayed a fax call because the sending device received a busy signal  |
	//	|                                 | multiple times. The device cannot retry the call because dialing restrictions    |
	//	|                                 | exist (some countries and regions restrict the number of retry attempts when a   |
	//	|                                 | number is busy).                                                                 |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_CALL_BLACKLISTED 0x20004000 | The device could not complete a call because the telephone number was blocked or |
	//	|                                 | reserved; emergency numbers such as 911 are blocked.                             |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_INITIALIZING 0x20008000     | The device is initializing a call.                                               |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_OFFLINE 0x20010000          | The device is offline and unavailable.                                           |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_RINGING 0x20020000          | The device is ringing.                                                           |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_AVAILABLE 0x20100000        | The device is available.                                                         |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_ABORTING 0x20200000         | The device is aborting a fax job.                                                |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_ROUTING 0x20400000          | The device is routing a received fax document.                                   |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_ANSWERED 0x20800000         | The device answered a new call.                                                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	Status uint32 `idl:"name:Status" json:"status"`
	// Size: A DWORD variable that indicates the total size, in bytes, of the fax document
	// to transmit, if known, or zero otherwise.  The size, if known, includes the size
	// of the cover page, if a cover page is present, and the size of the fax body, if a
	// fax body is present. The size MUST NOT exceed 4 gigabytes.
	Size uint32 `idl:"name:Size" json:"size"`
	// PageCount: A DWORD that indicates the total number of pages in the fax transmission,
	// including the cover page, if any, and the fax body, if any, of the fax submitted
	// with this fax job. If the fax is sent to multiple recipients, this total number of
	// pages is the number of fax pages sent to each individual recipient (not the sum of
	// the fax pages sent to all recipients).
	PageCount uint32 `idl:"name:PageCount" json:"page_count"`
	// RecipientNumber: A null-terminated character string that contains the fax number
	// of the recipient of the fax transmission, if known, or a NULL pointer otherwise.
	// This information comes from the recipient's personal profile.
	RecipientNumber string `idl:"name:RecipientNumber" json:"recipient_number"`
	// RecipientName: A null-terminated character string that contains the name of the recipient
	// of the fax, if known, or a NULL pointer otherwise. This information comes from the
	// recipient's personal profile.
	RecipientName string `idl:"name:RecipientName" json:"recipient_name"`
	// Tsid: A null-terminated character string that contains the transmitting subscriber
	// identifier (TSID), if known, or a NULL pointer otherwise. This information comes
	// from the sender's personal profile.
	TSID string `idl:"name:Tsid" json:"tsid"`
	// SenderName: A null-terminated character string that contains the fax sender name,
	// if known, or a NULL pointer otherwise. This information comes from the sender's personal
	// profile.
	SenderName string `idl:"name:SenderName" json:"sender_name"`
	// SenderCompany: A null-terminated character string that contains the fax sender company,
	// if known, or a NULL pointer otherwise. This information comes from the sender's personal
	// profile.
	SenderCompany string `idl:"name:SenderCompany" json:"sender_company"`
	// SenderDept: A null-terminated character string that contains the fax sender department,
	// if known, or a NULL pointer otherwise. This information comes from the sender's personal
	// profile.
	SenderDept string `idl:"name:SenderDept" json:"sender_dept"`
	// BillingCode: A null-terminated character string that contains the fax billing code,
	// if known, or a NULL pointer otherwise.
	BillingCode string `idl:"name:BillingCode" json:"billing_code"`
	// ScheduleAction: A DWORD that indicates when the fax is to be sent. This can be one
	// of the following values:
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|                                |                                                                                  |
	//	|           VALUE/CODE           |                                     MEANING                                      |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| JSA_NOW 0x00000000             | The fax is to be sent as soon as a fax device is available.                      |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| JSA_SPECIFIC_TIME 0x00000001   | The fax is to be sent at the time specified by the ScheduleTime field of this    |
	//	|                                | FAX_JOB_ENTRY structure.                                                         |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| JSA_DISCOUNT_PERIOD 0x00000002 | The fax is to be sent during the discount rate period. The                       |
	//	|                                | FaxObs_GetConfiguration (section 3.1.4.2.24) method can be called to retrieve    |
	//	|                                | the discount period for the fax server.                                          |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	ScheduleAction uint32 `idl:"name:ScheduleAction" json:"schedule_action"`
	// ScheduleTime: A SYSTEMTIME ([MS-DTYP] section 2.3.13) structure indicating the local
	// date and time to send the fax, in Coordinated Universal Time (UTC) format. This parameter
	// MUST be ignored unless the ScheduleAction parameter is set to 1 (JSA_SPECIFIC_TIME).
	ScheduleTime *dtyp.SystemTime `idl:"name:ScheduleTime" json:"schedule_time"`
	// DeliveryReportType: A DWORD variable that indicates the fax delivery report type.
	// This value MUST be one of the FAX_ENUM_DELIVERY_REPORT_TYPES (section 2.2.76) enumeration
	// values. The DRT_ATTACH_FAX value can be combined with the DRT_EMAIL value by an OR
	// operation.
	DeliveryReportType uint32 `idl:"name:DeliveryReportType" json:"delivery_report_type"`
	// DeliveryReportAddress: A null-terminated character string that contains the email
	// address for the delivery report, if known, or a NULL pointer otherwise.
	DeliveryReportAddress string `idl:"name:DeliveryReportAddress" json:"delivery_report_address"`
	// DocumentName: A null-terminated character string that contains the document name,
	// if known, or a NULL pointer otherwise.
	DocumentName string `idl:"name:DocumentName" json:"document_name"`
}

JobEntry structure represents FAX_JOB_ENTRY RPC structure.

The FAX_JOB_ENTRY structure describes one fax job. The structure includes information about the job type and status, the recipient's and the sender's personal profiles (section 3.1.1), scheduling and delivery settings, and the page count.

This structure is used as an input argument for the FaxObs_SetJob (section 3.1.4.2.11) method.

The _FAX_JOB_ENTRY structure is the custom-marshaled variant of the FAX_JOB_ENTRY (section 2.2.5) structure and describes one fax job. The structure includes information about the job type and status, the personal profiles (section 3.1.1) of the recipient and sender, scheduling and delivery settings, and the page count. The SizeOfStruct, RecipientNumber, and QueueStatus fields in the Fixed_Portion block MUST NOT be 0. Except for these fields and the JobId field, all fields of this structure are optional, and if the respective information is not available, the fields in the Fixed_Portion block MUST be zero.

An application can call the FAX_GetJob (section 3.1.4.1.41) method to retrieve information about a specified job at the server, information which is returned in a _FAX_JOB_ENTRY structure.

An application can call the FAX_EnumJobs function (section 3.1.4.1.21) to enumerate all queued and active fax jobs (see Fax Queue in section 3.1.1 for details) on the fax server of interest. The FAX_EnumJobs function returns an array of _FAX_JOB_ENTRY structures. Each structure describes one fax job in detail.

This structure is also returned as a single structure by the FaxObs_GetJob (section 3.1.4.2.10) method and as an array of structures by the FaxObs_EnumJobs (section 3.1.4.2.9) method.

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (92 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*JobEntry) MarshalNDR 

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

func (*JobEntry) UnmarshalNDR 

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

type JobParamExW 

type JobParamExW struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) that contains the size, in bytes,
	// of this structure. MUST be set to 44 bytes on 32-bit implementations, and MUST be
	// set to 64 bytes on 64-bit implementations.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// dwScheduleAction: A DWORD that MUST specify when to send the fax. This member MUST
	// be one of the following values.
	//
	//	+-----------------------+----------------------------------------------------------------------------------+
	//	|                       |                                                                                  |
	//	|      VALUE/CODE       |                                     MEANING                                      |
	//	|                       |                                                                                  |
	//	+-----------------------+----------------------------------------------------------------------------------+
	//	+-----------------------+----------------------------------------------------------------------------------+
	//	| JSA_NOW 0             | Send the fax as soon as a device is available.                                   |
	//	+-----------------------+----------------------------------------------------------------------------------+
	//	| JSA_SPECIFIC_TIME 1   | Send the fax at the time specified by the tmSchedule member.                     |
	//	+-----------------------+----------------------------------------------------------------------------------+
	//	| JSA_DISCOUNT_PERIOD 2 | Send the fax during the discount rate period. Call the FAX_GetConfiguration      |
	//	|                       | (section 3.1.4.1.36) function to retrieve the discount period for the fax        |
	//	|                       | server.                                                                          |
	//	+-----------------------+----------------------------------------------------------------------------------+
	ScheduleAction uint32 `idl:"name:dwScheduleAction" json:"schedule_action"`
	// tmSchedule: A SYSTEMTIME ([MS-DTYP] section 2.3.13) structure that contains the date
	// and time to send the fax. The time MUST be specified in UTC. This parameter SHOULD
	// be ignored unless dwScheduleAction is set to 1 (JSA_SPECIFIC_TIME). If the time specified
	// has already passed, the method behaves as if 0 (JSA_NOW) was specified.
	Schedule *dtyp.SystemTime `idl:"name:tmSchedule" json:"schedule"`
	// dwReceiptDeliveryType: A DWORD that holds the type of receipt delivered to the sender
	// when the fax is successfully sent and when the fax transmission fails. It can also
	// specify if a receipt will be sent for each recipient or for all the recipients together.
	// The value of this parameter MUST be a logical combination of one of the delivery
	// method flags and optionally one of the delivery grouping flags as specified in FAX_ENUM_DELIVERY_REPORT_TYPES
	// (section 2.2.76). The fax client MUST NOT use the DRT_INBOX value if the protocol
	// version reported by the server is FAX_API_VERSION_2 (0x00020000) or FAX_API_VERSION_3
	// (0x00030000). For more information, see FAX_ConnectFaxServer (section 3.1.4.1.10).
	ReceiptDeliveryType uint32 `idl:"name:dwReceiptDeliveryType" json:"receipt_delivery_type"`
	// lpwstrReceiptDeliveryAddress: A pointer to a constant, null-terminated character
	// string. If the dwReceiptDeliveryType member contains the DRT_EMAIL or DRT_ATTACH_FAX
	// flag, the string SHOULD be the address to which the delivery receipt (DR) or non-delivery
	// receipt (NDR) SHOULD be sent. If the dwReceiptDeliveryType member is equal to DRT_INBOX,
	// the string SHOULD be the name of the MAPI profile to which the DR or NDR SHOULD be
	// sent. For more information about MAPI, refer to [MSDN-MAPIPRF]. If the dwReceiptDeliveryType
	// member is equal to DRT_MSGBOX, the string SHOULD be the computer name to send the
	// receipt to as a text message containing a character string, as described in Messenger
	// Service Remote Protocol Specification [MS-MSRP] section 3.2.4.1. If the dwReceiptDeliveryType
	// member is set to DRT_NONE, the pointer SHOULD be NULL.
	ReceiptDeliveryAddress string `idl:"name:lpwstrReceiptDeliveryAddress;string" json:"receipt_delivery_address"`
	// Priority: A value specifying the priority level of the outgoing fax.
	Priority PriorityType `idl:"name:Priority" json:"priority"`
	// hCall: Reserved.
	HCall uint32 `idl:"name:hCall" json:"h_call"`

	// lpwstrDocumentName: A null-terminated character string that holds the document name.
	// A NULL pointer value specifies that no document name is specified for this fax job.
	DocumentName string `idl:"name:lpwstrDocumentName;string" json:"document_name"`
	// dwPageCount: A DWORD value that holds the number of pages in the fax document pointed
	// to by the lpcwstrFileName parameter of the FAX_SendDocumentEx (section 3.1.4.1.73)
	// method. This value MUST be used only for fax documents in TIFF, which is the only
	// supported format.
	PageCount uint32 `idl:"name:dwPageCount" json:"page_count"`
	// contains filtered or unexported fields
}

JobParamExW structure represents FAX_JOB_PARAM_EXW RPC structure.

The FAX_JOB_PARAM_EXW structure defines information about the new job to create when sending a fax message.

func (*JobParamExW) MarshalNDR 

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

func (*JobParamExW) UnmarshalNDR 

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

type JobParamW 

type JobParamW struct {
	// SizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) that contains the size, in bytes,
	// of this structure. This value MUST be 80 or 136 bytes. When filled in on a 32-bit
	// implementation, this value SHOULD be 80 bytes. When filled in on a 64-bit implementation,
	// this value SHOULD be 136 bytes.
	StructureSize uint32 `idl:"name:SizeOfStruct" json:"structure_size"`
	// RecipientNumber: A null-terminated character string that holds the fax number of
	// the fax transmission recipient.
	RecipientNumber string `idl:"name:RecipientNumber;string" json:"recipient_number"`
	// RecipientName: A null-terminated character string that holds the name of the fax
	// transmission recipient.
	RecipientName string `idl:"name:RecipientName;string" json:"recipient_name"`
	// Tsid: A null-terminated character string that holds the transmitting subscriber identifier
	// (TSID). The valid characters for a TSID string are the English letters, the numeric
	// symbols, and the punctuation marks (ASCII range 0x20 to 0x7F).
	TSID string `idl:"name:Tsid;string" json:"tsid"`
	// SenderName: A null-terminated character string that holds the name of the fax transmission
	// sender.
	SenderName string `idl:"name:SenderName;string" json:"sender_name"`
	// SenderCompany: A null-terminated character string that holds the name of the fax
	// transmission sender's company.
	SenderCompany string `idl:"name:SenderCompany;string" json:"sender_company"`
	// SenderDept: A null-terminated character string that holds the name of the fax transmission
	// sender's department.
	SenderDept string `idl:"name:SenderDept;string" json:"sender_dept"`
	// BillingCode: A null-terminated character string that holds an optional billing code
	// for the fax transmission.
	BillingCode string `idl:"name:BillingCode;string" json:"billing_code"`
	// ScheduleAction: A DWORD variable that indicates when the fax is to be sent. This
	// value can be one of the following values:
	//
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	|                                |                                                                                  |
	//	|           VALUE/CODE           |                                     MEANING                                      |
	//	|                                |                                                                                  |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| JSA_NOW 0x00000000             | The fax is to be sent as soon as a fax device is available.                      |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| JSA_SPECIFIC_TIME 0x00000001   | The fax is to be sent at the time specified by the ScheduleTime member of this   |
	//	|                                | structure.                                                                       |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	//	| JSA_DISCOUNT_PERIOD 0x00000002 | The fax is to be sent during the discount rate period. The                       |
	//	|                                | FaxObs_GetConfiguration (section 3.1.4.2.24) method can be called to retrieve    |
	//	|                                | the discount period for the fax server.                                          |
	//	+--------------------------------+----------------------------------------------------------------------------------+
	ScheduleAction uint32 `idl:"name:ScheduleAction" json:"schedule_action"`
	// ScheduleTime: A SYSTEMTIME ([MS-DTYP] section 2.3.13) structure indicating the local
	// date and time to send the fax, in UTC format. This member is used when the ScheduleAction
	// member is set to 0x00000001 (JSA_SPECIFIC_TIME), and is otherwise ignored.
	ScheduleTime *dtyp.SystemTime `idl:"name:ScheduleTime" json:"schedule_time"`
	// DeliveryReportType: A DWORD variable that indicates the fax delivery report type.
	// This value can be one of the FAX_ENUM_DELIVERY_REPORT_TYPES (section 2.2.76) enumeration
	// values. The DRT_ATTACH_FAX value can be combined with the DRT_EMAIL value in one
	// value by using an OR operation.
	DeliveryReportType uint32 `idl:"name:DeliveryReportType" json:"delivery_report_type"`
	// DeliveryReportAddress: A null-terminated character string. Contains the email address
	// for the delivery report when the DeliveryReportType member is set to 0x00000001 (DRT_E_MAIL).
	// Otherwise, this pointer value can be NULL.
	DeliveryReportAddress string `idl:"name:DeliveryReportAddress;string" json:"delivery_report_address"`
	// DocumentName: A null-terminated character string that holds the document name. A
	// NULL pointer value specifies that no document name is specified for this fax job.
	DocumentName string `idl:"name:DocumentName;string" json:"document_name"`
	// CallHandle: An unsigned 32-bit integer value containing an optional TAPI call handle.
	// For more information about TAPI, see [MSDN-TAPI2.2]. For more information about this
	// member, see FaxObs_SendDocument.
	CallHandle uint32 `idl:"name:CallHandle" json:"call_handle"`
	// contains filtered or unexported fields
}

JobParamW structure represents FAX_JOB_PARAMW RPC structure.

The FAX_JOB_PARAMW structure contains information about a fax job, including information about the personal profiles (section 3.1.1) for the sender and the recipient of the fax. This structure is used as an input argument for the FaxObs_SendDocument (section 3.1.4.2.7) method.

func (*JobParamW) MarshalNDR 

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

func (*JobParamW) UnmarshalNDR 

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

type MessageEnum 

type MessageEnum dcetypes.ContextHandle

MessageEnum structure represents RPC_FAX_MSG_ENUM_HANDLE RPC structure.

func (*MessageEnum) ContextHandle 

func (o *MessageEnum) ContextHandle() *dcetypes.ContextHandle

func (*MessageEnum) MarshalNDR 

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

func (*MessageEnum) UnmarshalNDR 

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

type MessageFolder 

type MessageFolder uint16

MessageFolder type represents FAX_ENUM_MESSAGE_FOLDER RPC enumeration.

The FAX_ENUM_MESSAGE_FOLDER enumeration defines possible locations for a fax message. 

var (
	// FAX_MESSAGE_FOLDER_INBOX: The incoming fax transmission archive, defined in section
	// 3.1.1.
	MessageFolderInbox MessageFolder = 0
	// FAX_MESSAGE_FOLDER_SENTITEMS: The outgoing fax transmission archive, defined in section
	// 3.1.1.
	MessageFolderSentitems MessageFolder = 1
	// FAX_MESSAGE_FOLDER_QUEUE: The Outgoing and Incoming fax queue, defined in section
	// 3.1.1.
	MessageFolderQueue MessageFolder = 2
)

func (MessageFolder) String 

func (o MessageFolder) String() string

type MessageProperties 

type MessageProperties struct {
	// dwValidityMask: A DWORD ([MS-DTYP] section 2.2.9) value that defines a bitwise combination
	// of valid fields in the structure.
	//
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	|                                     |                                                                                  |
	//	|             VALUE/CODE              |                                     MEANING                                      |
	//	|                                     |                                                                                  |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	//	| FAX_MSG_PROP_FIELD_MSG_FLAGS 0x0001 | Indicates whether the value in dwMsgFlags is valid. If this bit is set, the      |
	//	|                                     | value in dwMsgFlags is valid.                                                    |
	//	+-------------------------------------+----------------------------------------------------------------------------------+
	ValidityMask uint32 `idl:"name:dwValidityMask" json:"validity_mask"`
	// dwMsgFlags: A DWORD bitmask that specifies the state to which the message flags are
	// set.
	//
	//	+------------------------------+----------------------------------------------------------------------------------+
	//	|                              |                                                                                  |
	//	|          VALUE/CODE          |                                     MEANING                                      |
	//	|                              |                                                                                  |
	//	+------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------+----------------------------------------------------------------------------------+
	//	| FAX_MSG_FLAG_READ 0x00000001 | Determines whether this fax message is marked as read. If this bit is set,       |
	//	|                              | the message is marked as read. If this bit is reset, the message is marked as    |
	//	|                              | unread.                                                                          |
	//	+------------------------------+----------------------------------------------------------------------------------+
	MessageFlags uint32 `idl:"name:dwMsgFlags" json:"message_flags"`
}

MessageProperties structure represents FAX_MESSAGE_PROPS RPC structure.

The FAX_MESSAGE_PROPS structure defines the properties of a fax message that can be set.

func (*MessageProperties) MarshalNDR 

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

func (*MessageProperties) UnmarshalNDR 

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

type OutboundRoutingGroupw 

type OutboundRoutingGroupw struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size
	// of the structure, in bytes. This value MUST be 20 or 40 bytes. When filled in on
	// a 32-bit implementation, this value SHOULD be 20 bytes. When filled in on a 64-bit
	// implementation, this value SHOULD be 40 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// lpwstrGroupName: A null-terminated character string containing the group name. The
	// length of this string MUST be between 1 and 128 characters, excluding the length
	// of the terminating null character. The group name is case-insensitive.
	GroupName string `idl:"name:lpwstrGroupName;string" json:"group_name"`
	// dwNumDevices: A DWORD value that holds the number of devices in the group. The value
	// MUST be in the range between 0 and 1,000. The dwNumDevices parameter also indicates
	// the length of the lpdwDevices array, which is not larger than the actual number of
	// devices.
	DevicesLength uint32 `idl:"name:dwNumDevices" json:"devices_length"`
	// lpdwDevices: A pointer to a DWORD array which contains dwNumDevices entries. Each
	// DWORD value specifies one device identifier in the group. A device MUST only appear
	// once in a group's device list. A single device can belong to one or more groups.
	// Groups are not set to store invalid devices. The order of the devices in the array
	// determines the order the devices are to be used to send faxes, when the group is
	// selected.
	Devices []uint32 `idl:"name:lpdwDevices;size_is:(dwNumDevices);pointer:unique" json:"devices"`
	// Status: Current status of the group from the enumeration FAX_ENUM_GROUP_STATUS (section
	// 2.2.59).
	Status GroupStatus `idl:"name:Status" json:"status"`
}

OutboundRoutingGroupw structure represents RPC_FAX_OUTBOUND_ROUTING_GROUPW RPC structure.

The _RPC_FAX_OUTBOUND_ROUTING_GROUPW data type is used as an array of structures passed as an output byte-array argument for FAX_EnumOutboundGroups (section 3.1.4.1.26). The group name contained by this structure describes one Routing Group (section 3.1.1).

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (16 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

The RPC_FAX_OUTBOUND_ROUTING_GROUPW data type is used as an input argument for FAX_SetOutboundGroup (section 3.1.4.1.85). The group name contained by this structure describes one Routing Group (section 3.1.1).

For reference, the data type definition is shown as follows.

func (*OutboundRoutingGroupw) MarshalNDR 

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

func (*OutboundRoutingGroupw) UnmarshalNDR 

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

type OutboundRoutingRuleW 

type OutboundRoutingRuleW struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size
	// of the structure, in bytes. This value MUST be 24 or 40 bytes. When filled in on
	// a 32-bit implementation, this value SHOULD be 24 bytes. When filled in on a 64-bit
	// implementation this value SHOULD be 40 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// dwAreaCode: A DWORD that contains the area code of the rule. A value of zero indicates
	// the special any-area value ROUTING_RULE_AREA_CODE_ANY. The dwAreaCode and dwCountryCode
	// members MUST form a unique key. This value is unrestricted.
	AreaCode uint32 `idl:"name:dwAreaCode" json:"area_code"`
	// dwCountryCode: A DWORD that contains the country/region code of the rule. A value
	// of zero indicates the special any-country, any-region value ROUTING_RULE_COUNTRY_CODE_ANY.
	// The dwAreaCode and dwCountryCode numeric values MUST form a unique key. Clients can
	// obtain valid values with the FAX_GetCountryList (section 3.1.4.1.37) method.
	CountryCode uint32 `idl:"name:dwCountryCode" json:"country_code"`
	// lpwstrCountryName: A pointer to a null-terminated string that contains the country/region
	// name indicated by the dwCountryCode parameter if known; otherwise, a NULL pointer.
	// If dwCountryCode is zero, this pointer MUST be NULL.
	CountryName string `idl:"name:lpwstrCountryName;string" json:"country_name"`
	// Destination: A FAX_RULE_DESTINATION (section 2.2.81) union that contains the destination
	// of the rule. When bUseGroup is FALSE, this union value MUST hold a device identifier;
	// otherwise, this union value MUST represent the name of an outbound routing group
	// of devices.
	Destination *RuleDestination `idl:"name:Destination;switch_is:bUseGroup" json:"destination"`
	// bUseGroup: A Boolean value that indicates whether the group is used in the destination.
	// If TRUE, the group MUST be used as the rule's destination. If FALSE, the device MUST
	// be used as the rule's destination.
	UseGroup bool `idl:"name:bUseGroup" json:"use_group"`
}

OutboundRoutingRuleW structure represents RPC_FAX_OUTBOUND_ROUTING_RULEW RPC structure.

The RPC_FAX_OUTBOUND_ROUTING_RULEW data type is used as an input argument for FAX_SetOutboundRule (section 3.1.4.1.86). The information contained in this structure describes one routing rule in the Configuration of the Routing Rules (section 3.1.1).

For reference, the data type definition is as follows.

The _RPC_FAX_OUTBOUND_ROUTING_RULEW data type is used as an array of structures passed as an output byte-array argument for FAX_EnumOutboundRules (section 3.1.4.1.27). The information contained in each _RPC_FAX_OUTBOUND_ROUTING_RULEW structure describes one routing rule in the Configuration of the Routing Rules (section 3.1.1).

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (24 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*OutboundRoutingRuleW) MarshalNDR 

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

func (*OutboundRoutingRuleW) UnmarshalNDR 

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

type OutboxConfig 

type OutboxConfig struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size
	// of the structure, in bytes. This value MUST be 36 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// bAllowPersonalCP: A Boolean that indicates whether fax client applications can include
	// a user-designed cover page template with the fax transmission. If this member is
	// TRUE, the client can provide a personal cover page template. If this member is FALSE,
	// the client MUST use a common cover page stored on the fax server.
	AllowPersonalCreatePartition bool `idl:"name:bAllowPersonalCP" json:"allow_personal_create_partition"`
	// bUseDeviceTSID: A Boolean variable that indicates whether the fax server MAY use
	// the devices transmitting subscriber identifier instead of the value specified when
	// submitting a new job. If this member is TRUE, the server SHOULD use the devices transmitting
	// subscriber identifier.
	UseDeviceTSID bool `idl:"name:bUseDeviceTSID" json:"use_device_tsid"`
	// dwRetries: A DWORD that holds the number of times the fax server will attempt to
	// retransmit an outgoing fax if the initial transmission fails.
	Retries uint32 `idl:"name:dwRetries" json:"retries"`
	// dwRetryDelay: A DWORD that holds the minimum number of minutes that will elapse between
	// retransmission attempts by the fax server.
	RetryDelay uint32 `idl:"name:dwRetryDelay" json:"retry_delay"`
	// dtDiscountStart: A FAX_TIME (section 2.2.61) structure that MUST specify the hour
	// and minute at which the discount period begins. The discount period applies only
	// to outgoing transmissions.
	DiscountStart *Time `idl:"name:dtDiscountStart" json:"discount_start"`
	// dtDiscountEnd: A FAX_TIME structure that holds the hour and minute at which the discount
	// period ends. The discount period applies only to outgoing transmissions.
	DiscountEnd *Time `idl:"name:dtDiscountEnd" json:"discount_end"`
	// dwAgeLimit: A DWORD variable that holds the number of days the fax server will keep
	// unsuccessful fax messages in its outbox queue. If a fax message stays in the outbox
	// queue longer than the value specified, it MAY be automatically deleted. If this value
	// is zero, the time limit MUST NOT be used.
	AgeLimit uint32 `idl:"name:dwAgeLimit" json:"age_limit"`
	// bBranding: A Boolean that indicates whether the fax server generates a brand (banner)
	// at the top of outgoing fax transmissions. If this member is TRUE, the fax server
	// SHOULD generate a brand that contains transmission-related information such as the
	// transmitting subscriber identifier, date, time, and page count.
	Branding bool `idl:"name:bBranding" json:"branding"`
}

OutboxConfig structure represents FAX_OUTBOX_CONFIG RPC structure.

The FAX_OUTBOX_CONFIG structure defines information about outbox settings of the fax server. This data structure is used as a parameter to the FAX_SetOutboxConfiguration (section 3.1.4.1.87) method.

The _FAX_OUTBOX_CONFIG data type is the custom-marshaled variant of the FAX_OUTBOX_CONFIG (section 2.2.16) data structure. The _FAX_OUTBOX_CONFIG data type is returned from the FAX_GetOutboxConfiguration (section 3.1.4.1.47) method.

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (36 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*OutboxConfig) MarshalNDR 

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

func (*OutboxConfig) UnmarshalNDR 

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

type PersonalProfileTypes 

type PersonalProfileTypes uint16

PersonalProfileTypes type represents FAX_ENUM_PERSONAL_PROF_TYPES RPC enumeration.

The FAX_ENUM_PERSONAL_PROF_TYPES enumeration defines values to indicate personal profile types. 

var (
	// RECIPIENT_PERSONAL_PROF: Indicates a recipient profile.
	PersonalProfileTypesRecipientPersonalProfile PersonalProfileTypes = 1
	// SENDER_PERSONAL_PROF: Indicates a sender profile.
	PersonalProfileTypesSenderPersonalProfile PersonalProfileTypes = 2
)

func (PersonalProfileTypes) String 

func (o PersonalProfileTypes) String() string

type Port 

type Port dcetypes.ContextHandle

Port structure represents RPC_FAX_PORT_HANDLE RPC structure.

func (*Port) ContextHandle 

func (o *Port) ContextHandle() *dcetypes.ContextHandle

func (*Port) MarshalNDR 

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

func (*Port) UnmarshalNDR 

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

type PortInfo 

type PortInfo struct {
	// SizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) that holds the size of the structure,
	// in bytes. This value MUST be 36 bytes or 48 bytes. When filled in on a 32-bit implementation,
	// this value SHOULD be 36 bytes. When filled in on a 64-bit implementation, this value
	// SHOULD be 48 bytes.
	StructureSize uint32 `idl:"name:SizeOfStruct" json:"structure_size"`
	// DeviceId: A DWORD variable that holds the line identifier for the fax device (port)
	// of interest.
	DeviceID uint32 `idl:"name:DeviceId" json:"device_id"`
	// State: A DWORD variable that holds a fax device status code or value. This member
	// can be one of the following predefined device status codes.
	//
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	|                                 |                                                                                  |
	//	|           VALUE/CODE            |                                     MEANING                                      |
	//	|                                 |                                                                                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_DIALING 0x20000001          | The device is dialing a fax number.                                              |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_SENDING 0x20000002          | The device is sending a fax document.                                            |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_RECEIVING 0x20000004        | The device is receiving a fax document.                                          |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_COMPLETED 0x20000008        | The device completed sending or receiving a fax transmission.                    |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_HANDLED 0x20000010          | The fax service processed the outbound fax document; the fax service provider    |
	//	|                                 | (FSP) will transmit the fax document.                                            |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_UNAVAILABLE 0x20000020      | The device is not available because it is in use by another application.         |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_BUSY 0x20000040             | The device encountered a busy signal.                                            |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_NO_ANSWER 0x20000080        | The receiving device did not answer the call.                                    |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_BAD_ADDRESS 0x20000100      | The device dialed an invalid fax number.                                         |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_NO_DIAL_TONE 0x20000200     | The sending device cannot complete the call because it does not detect a dial    |
	//	|                                 | tone.                                                                            |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_DISCONNECTED 0x20000400     | The fax call was disconnected by the sender or the caller.                       |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_FATAL_ERROR 0x20000800      | The device has encountered a fatal protocol error.                               |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_NOT_FAX_CALL 0x20001000     | The device received a call that was a data call or a voice call.                 |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_CALL_DELAYED 0x20002000     | The device delayed a fax call because the sending device received a busy signal  |
	//	|                                 | multiple times. The device cannot retry the call because dialing restrictions    |
	//	|                                 | exist (some countries and regions restrict the number of retry attempts when a   |
	//	|                                 | number is busy).                                                                 |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_CALL_BLACKLISTED 0x20004000 | The device could not complete a call because the telephone number was blocked or |
	//	|                                 | reserved; emergency numbers such as 911 are blocked.                             |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_INITIALIZING 0x20008000     | The device is initializing a call.                                               |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_OFFLINE 0x20010000          | The device is offline and unavailable.                                           |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_RINGING 0x20020000          | The device is ringing.                                                           |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_AVAILABLE 0x20100000        | The device is available.                                                         |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_ABORTING 0x20200000         | The device is aborting a fax job.                                                |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_ROUTING 0x20400000          | The device is routing a received fax document.                                   |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	//	| FPS_ANSWERED 0x20800000         | The device answered a new call.                                                  |
	//	+---------------------------------+----------------------------------------------------------------------------------+
	State uint32 `idl:"name:State" json:"state"`
	// Flags: A DWORD variable that holds a set of bit flags that specify the capability
	// of the fax port. This member can be a bitwise OR combination of the following flag
	// values.
	//
	//	+------------------------+----------------------------------------------------------------------------------+
	//	|                        |                                                                                  |
	//	|       VALUE/CODE       |                                     MEANING                                      |
	//	|                        |                                                                                  |
	//	+------------------------+----------------------------------------------------------------------------------+
	//	+------------------------+----------------------------------------------------------------------------------+
	//	| FPF_RECEIVE 0x00000001 | The device can receive faxes.                                                    |
	//	+------------------------+----------------------------------------------------------------------------------+
	//	| FPF_SEND 0x00000002    | The device can send faxes.                                                       |
	//	+------------------------+----------------------------------------------------------------------------------+
	//	| FPF_VIRTUAL 0x00000004 | The device is a virtual fax device. Note that the implementer cannot set a       |
	//	|                        | device to be virtual. When FAX_GetPort (section 3.1.4.1.51) is called, the       |
	//	|                        | FAX_PORT_INFO flag's FPF_VIRTUAL value indicates whether the device is virtual.  |
	//	|                        | When FAX_SetPort (section 3.1.4.1.88) is called, the service will only relate to |
	//	|                        | the FPF_RECEIVE and FPF_SEND values.                                             |
	//	+------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:Flags" json:"flags"`
	// Rings: A DWORD variable that holds the number of times an incoming fax call rings
	// before the specified device answers the call. Values can be from 0 to 99 inclusive.
	// This value SHOULD be ignored unless the FPF_RECEIVE port capability bit flag is set.
	Rings uint32 `idl:"name:Rings" json:"rings"`
	// Priority: A DWORD variable that holds the priority that determines the relative order
	// in which available fax devices send outgoing transmissions. Values for this member
	// can be 1 through n, where n is the value of the PortsReturned parameter returned
	// by a call to the FAX_EnumPorts (section 3.1.4.1.28) function. When the fax server
	// initiates an outgoing fax transmission, it attempts to select the device with the
	// highest priority and FPF_SEND port capability. If that device is not available, the
	// server selects the next available device that follows in rank order, and so on. The
	// value of the Priority member has no effect on incoming transmissions.
	Priority uint32 `idl:"name:Priority" json:"priority"`
	// DeviceName: A pointer to a constant null-terminated character string that holds the
	// name of the fax device of interest.
	DeviceName string `idl:"name:DeviceName;string" json:"device_name"`
	// Tsid: A pointer to a constant null-terminated character string that holds the transmitting
	// subscriber identifier (TSID). This identifier is usually a telephone number. Only
	// English letters, numeric symbols, and punctuation marks (ASCII range 0x20 to 0x7F)
	// can be used in a TSID.
	TSID string `idl:"name:Tsid;string" json:"tsid"`
	// Csid: A pointer to a constant null-terminated character string that holds the called
	// subscriber identifier (CSID). This identifier is usually a telephone number. Only
	// English letters, numeric symbols, and punctuation marks (ASCII range 0x20 to 0x7F)
	// can be used in a CSID.
	CSID string `idl:"name:Csid;string" json:"csid"`
}

PortInfo structure represents FAX_PORT_INFO RPC structure.

The FAX_PORT_INFO structure describes one fax port. The data includes, among other items, a device identifier, the port's name and current status, and subscriber identifiers.

A fax client application passes the FAX_PORT_INFO in a call to the FAX_SetPort (section 3.1.4.1.88) function to modify the configuration of the fax port of interest.

This structure is also used as an input argument for the FaxObs_SetPort (section 3.1.4.2.17) method.

The _FAX_PORT_INFO data structure is the custom-marshaled variant of the FAX_PORT_INFO (section 2.2.7) data structure. This structure describes one fax port. The data includes, among other items, a device identifier, the port's name and current status, and subscriber identifiers.

If an application calls the FAX_EnumPorts (section 3.1.4.1.28) function to enumerate all the fax devices currently attached to a fax server, the function returns a byte array of _FAX_PORT_INFO structures. Each structure describes one device in detail.

If an application calls the FAX_GetPort (section 3.1.4.1.51) function to query one device, that function returns information about the device in one _FAX_PORT_INFO.

This structure is also returned as a single structure by the FaxObs_GetPort (section 3.1.4.2.16) method and as an array of structures by the FaxObs_EnumPorts (section 3.1.4.2.15) method.

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (36 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

The _FAX_PORT_INFO data structure is the custom-marshaled variant of the FAX_PORT_INFO (section 2.2.7) data structure. This structure describes one fax port. The data includes, among other items, a device identifier, the port's name and current status, and subscriber identifiers.

If an application calls the FAX_EnumPorts (section 3.1.4.1.28) function to enumerate all the fax devices currently attached to a fax server, the function returns a byte array of _FAX_PORT_INFO structures. Each structure describes one device in detail.

If an application calls the FAX_GetPort (section 3.1.4.1.51) function to query one device, that function returns information about the device in one _FAX_PORT_INFO.

This structure is also returned as a single structure by the FaxObs_GetPort (section 3.1.4.2.16) method and as an array of structures by the FaxObs_EnumPorts (section 3.1.4.2.15) method.

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (36 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*PortInfo) MarshalNDR 

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

func (*PortInfo) UnmarshalNDR 

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

type PortInfoExW 

type PortInfoExW struct {
	// dwSizeOfStruct: DWORD ([MS-DTYP] section 2.2.9) value that holds the total size of
	// the structure, in bytes. This value MUST be 48 or 72 bytes. When filled in on a 32-bit
	// implementation, this value SHOULD be 48 bytes. When filled in on a 64-bit implementation,
	// this value SHOULD be 72 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// dwDeviceID: A DWORD that holds the line identifier for the specified fax device (port).
	DeviceID uint32 `idl:"name:dwDeviceID" json:"device_id"`
	// lpcwstrDeviceName: A null-terminated character string that holds the name of the
	// fax device.
	DeviceName string `idl:"name:lpcwstrDeviceName;string" json:"device_name"`
	// lpwstrDescription: A null-terminated character string that holds the description
	// of the fax device. The length of this string MUST NOT exceed MAX_FAX_STRING_LEN (section
	// 2.2.86) characters, including the length of the terminating null character.
	Description string `idl:"name:lpwstrDescription;string" json:"description"`
	// lpcwstrProviderName: A null-terminated character string that holds the name of the
	// fax device provider.
	ProviderName string `idl:"name:lpcwstrProviderName;string" json:"provider_name"`
	// lpcwstrProviderGUID: A null-terminated character string that holds the GUID of the
	// fax device provider.
	ProviderGUID string `idl:"name:lpcwstrProviderGUID;string" json:"provider_guid"`
	// bSend: A Boolean value that indicates whether the fax device is enabled to send faxes.
	Send bool `idl:"name:bSend" json:"send"`
	// ReceiveMode: An FAX_ENUM_DEVICE_RECEIVE_MODE (section 2.2.55) enumeration value that
	// indicates whether the fax device is enabled to receive faxes and whether the calls
	// are manually or automatically answered.
	ReceiveMode DeviceReceiveMode `idl:"name:ReceiveMode" json:"receive_mode"`
	// dwStatus: A DWORD that holds the current status of the device. It SHOULD contain
	// any combination of values from the FAX_ENUM_DEVICE_STATUS (section 2.2.64) enumeration
	// or 0 (meaning: status unknown).
	Status uint32 `idl:"name:dwStatus" json:"status"`
	// dwRings: A DWORD that holds the number of times an incoming fax call rings before
	// the specified device answers the call.
	Rings uint32 `idl:"name:dwRings" json:"rings"`
	// lpwstrCsid: A null-terminated character string that holds the called subscriber identifier
	// for faxes sent using this device. This identifier can be a telephone number.
	CSID string `idl:"name:lpwstrCsid;string" json:"csid"`
	// lpwstrTsid: A null-terminated character string that holds the transmitting subscriber
	// identifier for faxes sent using this device. This identifier can be a telephone number.
	TSID string `idl:"name:lpwstrTsid;string" json:"tsid"`
}

PortInfoExW structure represents FAX_PORT_INFO_EXW RPC structure.

The FAX_PORT_INFO_EXW structure defines information about a single fax device, known as a port. This structure is used for FAX_SetPortEx (section 3.1.4.1.89).

The _FAX_PORT_INFO_EXW data type is the custom-marshaled variant of the FAX_PORT_INFO_EXW (section 2.2.45) structure. This data type is used for FAX_EnumPortsEx (section 3.1.4.1.29) and FAX_GetPortEx (section 3.1.4.1.52).

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (48 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

The _FAX_PORT_INFO_EXW data type is the custom-marshaled variant of the FAX_PORT_INFO_EXW (section 2.2.45) structure. This data type is used for FAX_EnumPortsEx (section 3.1.4.1.29) and FAX_GetPortEx (section 3.1.4.1.52).

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (48 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

func (*PortInfoExW) MarshalNDR 

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

func (*PortInfoExW) UnmarshalNDR 

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

type PriorityType 

type PriorityType uint16

PriorityType type represents FAX_ENUM_PRIORITY_TYPE RPC enumeration.

The FAX_ENUM_PRIORITY_TYPE enumeration defines types of priorities for outgoing faxes. 

var (
	// FAX_PRIORITY_TYPE_LOW: The fax is sent with a low priority.
	PriorityTypeLow PriorityType = 0
	// FAX_PRIORITY_TYPE_NORMAL: The fax is sent with a normal priority.
	PriorityTypeNormal PriorityType = 1
	// FAX_PRIORITY_TYPE_HIGH: The fax is sent with a high priority.
	PriorityTypeHigh PriorityType = 2
)

func (PriorityType) String 

func (o PriorityType) String() string

type ProductSKUType 

type ProductSKUType uint16

ProductSKUType type represents PRODUCT_SKU_TYPE RPC enumeration.

The PRODUCT_SKU_TYPE enumeration provides values that identify the different Stock Keeping Unit (SKU) versions of an operating system.<28> 

var (
	// PRODUCT_SKU_UNKNOWN: The operating system is unknown.
	ProductSKUTypeUnknown ProductSKUType = 0
	// PRODUCT_SKU_PERSONAL: Client Personal Edition.
	ProductSKUTypePersonal ProductSKUType = 1
	// PRODUCT_SKU_PROFESSIONAL: Client Professional Edition.
	ProductSKUTypeProfessional ProductSKUType = 2
	// PRODUCT_SKU_SERVER: Server Standard Edition.
	ProductSKUTypeServer ProductSKUType = 4
	// PRODUCT_SKU_ADVANCED_SERVER: Server Advanced Edition
	ProductSKUTypeAdvancedServer ProductSKUType = 8
	// PRODUCT_SKU_DATA_CENTER: Server Datacenter Edition.
	ProductSKUTypeDataCenter ProductSKUType = 16
	// PRODUCT_SKU_DESKTOP_EMBEDDED: Client Embedded Edition.
	ProductSKUTypeDesktopEmbedded ProductSKUType = 32
	// PRODUCT_SKU_SERVER_EMBEDDED: Server Embedded Edition.
	ProductSKUTypeServerEmbedded ProductSKUType = 64
	// PRODUCT_SKU_WEB_SERVER: Server Web Server Edition.
	ProductSKUTypeWebServer ProductSKUType = 128
)

func (ProductSKUType) String 

func (o ProductSKUType) String() string

type ReassignInfo 

type ReassignInfo struct {
	// lpcwstrRecipients: A pointer to a constant, null-terminated character string that
	// holds an array of intended recipients to which the fax message can be assigned. The
	// recipients are separated by a semicolon. Each recipient refers to a Fax User Account.
	Recipients string `idl:"name:lpcwstrRecipients;string" json:"recipients"`
	// lpcwstrSenderName: A pointer to a constant null-terminated character string that
	// describes the sender name for the received fax.
	SenderName string `idl:"name:lpcwstrSenderName;string" json:"sender_name"`
	// lpcwstrSenderFaxNumber: A pointer to a constant null-terminated character string
	// that describes the sender fax number for the received fax.
	SenderFaxNumber string `idl:"name:lpcwstrSenderFaxNumber;string" json:"sender_fax_number"`
	// lpcwstrSubject: A pointer to a constant, null-terminated character string that describes
	// the subject of the received fax.
	Subject string `idl:"name:lpcwstrSubject;string" json:"subject"`
	// bHasCoverPage: Boolean value that indicates whether the fax includes a cover page.
	// If this member is TRUE, the fax SHOULD include a cover page.
	HasCoverPage bool `idl:"name:bHasCoverPage" json:"has_cover_page"`
}

ReassignInfo structure represents FAX_REASSIGN_INFO RPC structure.

The FAX_REASSIGN_INFO structure contains information about the reassignment of a fax.

func (*ReassignInfo) MarshalNDR 

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

func (*ReassignInfo) UnmarshalNDR 

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

type ReceiptsConfigW 

type ReceiptsConfigW struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size
	// of the structure, in bytes. This value MUST be 40 or 72 bytes. When filled in on
	// a 32-bit implementation, this value SHOULD be 40 bytes. When filled in on a 64-bit
	// implementation, this value SHOULD be 72 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// dwAllowedReceipts: A DWORD that holds the type of receipts that the server supports.
	// This member MUST be one of the values defined in FAX_ENUM_DELIVERY_REPORT_TYPES (section
	// 2.2.76).
	AllowedReceipts uint32 `idl:"name:dwAllowedReceipts" json:"allowed_receipts"`
	// SMTPAuthOption: A type of SMTP authentication that the server will use for SMTP connections.
	// The options MUST be one of the enumerations defined in FAX_ENUM_SMTP_AUTH_OPTIONS
	// (section 2.2.56).
	SMTPAuthOption SMTPAuthOptions `idl:"name:SMTPAuthOption" json:"smtp_auth_option"`

	// lpwstrSMTPServer: A null-terminated character string that holds the SMTP server name.
	SMTPServer string `idl:"name:lpwstrSMTPServer;string" json:"smtp_server"`
	// dwSMTPPort: A DWORD that holds the port number of the SMTP server.
	SMTPPort uint32 `idl:"name:dwSMTPPort" json:"smtp_port"`
	// lpwstrSMTPFrom: A null-terminated character string that holds the SMTP email address
	// of the sender of the fax receipt messages.
	SMTPFrom string `idl:"name:lpwstrSMTPFrom;string" json:"smtp_from"`
	// lpwstrSMTPUserName: A null-terminated character string that holds the user name to
	// use for Basic-authenticated SMTP connections.
	SMTPUserName string `idl:"name:lpwstrSMTPUserName;string" json:"smtp_user_name"`
	// lpwstrSMTPPassword: A null-terminated character string that holds the password to
	// use for Basic-authenticated SMTP connections. For anonymous access, no user name
	// and password is required. For Basic and Integrated authentication, a cleartext password
	// is sent over the wire. It is for the server to use the password that depends on the
	// authentication mode.
	SMTPPassword string `idl:"name:lpwstrSMTPPassword;string" json:"smtp_password"`
	// bIsToUseForMSRouteThroughEmailMethod: If set to TRUE, the routing extension MUST
	// use the DRT_EMAIL receipts settings to route incoming faxes by email.
	IsToUseForMsRouteThroughEmailMethod bool `idl:"name:bIsToUseForMSRouteThroughEmailMethod" json:"is_to_use_for_ms_route_through_email_method"`
	// contains filtered or unexported fields
}

ReceiptsConfigW structure represents FAX_RECEIPTS_CONFIGW RPC structure.

The _FAX_RECEIPTS_CONFIGW data type is the custom-marshaled variant of the FAX_RECEIPTS_CONFIGW (section 2.2.47) structure. This data type is used by FAX_GetReceiptsConfiguration (section 3.1.4.1.54).

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (40 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Variable_Data (variable)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

The FAX_RECEIPTS_CONFIGW structure defines the format for the receipt settings of the fax server. This structure is used by FAX_SetReceiptsConfiguration (section 3.1.4.1.91). The information contained by this structure describes the delivery receipt support fax server configuration (section 3.1.1).

func (*ReceiptsConfigW) MarshalNDR 

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

func (*ReceiptsConfigW) UnmarshalNDR 

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

type RuleDestination 

type RuleDestination struct {
	// Types that are assignable to Value
	//
	// *RuleDestination_DeviceID
	// *RuleDestination_GroupName
	Value is_RuleDestination `json:"value"`
}

RuleDestination structure represents FAX_RULE_DESTINATION RPC union.

func (*RuleDestination) GetValue 

func (o *RuleDestination) GetValue() any

func (*RuleDestination) MarshalUnionNDR 

func (o *RuleDestination) MarshalUnionNDR(ctx context.Context, w ndr.Writer, sw int32) error

func (*RuleDestination) NDRSwitchValue 

func (o *RuleDestination) NDRSwitchValue(sw int32) int32

func (*RuleDestination) UnmarshalUnionNDR 

func (o *RuleDestination) UnmarshalUnionNDR(ctx context.Context, w ndr.Reader, sw int32) error

type RuleDestination_DeviceID 

type RuleDestination_DeviceID struct {
	DeviceID uint32 `idl:"name:dwDeviceId" json:"device_id"`
}

RuleDestination_DeviceID structure represents FAX_RULE_DESTINATION RPC union arm.

It has following labels: 0

func (*RuleDestination_DeviceID) MarshalNDR 

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

func (*RuleDestination_DeviceID) UnmarshalNDR 

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

type RuleDestination_GroupName 

type RuleDestination_GroupName struct {
	GroupName string `idl:"name:lpwstrGroupName;string" json:"group_name"`
}

RuleDestination_GroupName structure represents FAX_RULE_DESTINATION RPC default union arm.

func (*RuleDestination_GroupName) MarshalNDR 

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

func (*RuleDestination_GroupName) UnmarshalNDR 

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

type RuleStatus 

type RuleStatus uint16

RuleStatus type represents FAX_ENUM_RULE_STATUS RPC enumeration.

The FAX_ENUM_RULE_STATUS enumeration defines the possible status values for an outbound routing rule. 

var (
	// FAX_RULE_STATUS_VALID: Indicates this outbound routing rule is valid.
	RuleStatusValid RuleStatus = 0
	// FAX_RULE_STATUS_EMPTY_GROUP: Indicates the rule's destination group has no devices.
	RuleStatusEmptyGroup RuleStatus = 1
	// FAX_RULE_STATUS_ALL_GROUP_DEV_NOT_VALID: Indicates that all devices in the rule's
	// destination group are invalid.
	RuleStatusAllGroupDevNotValid RuleStatus = 2
	// FAX_RULE_STATUS_SOME_GROUP_DEV_NOT_VALID: Indicates the rule's destination group
	// has some invalid devices.
	RuleStatusSomeGroupDevNotValid RuleStatus = 3
	// FAX_RULE_STATUS_BAD_DEVICE: Indicates the rule's destination device is not valid.
	RuleStatusBadDevice RuleStatus = 4
)

func (RuleStatus) String 

func (o RuleStatus) String() string

type SMTPAuthOptions 

type SMTPAuthOptions uint16

SMTPAuthOptions type represents FAX_ENUM_SMTP_AUTH_OPTIONS RPC enumeration.

The FAX_ENUM_SMTP_AUTH_OPTIONS enumeration defines the type of authentication used for SMTP connections. 

var (
	// FAX_SMTP_AUTH_ANONYMOUS: The server will send fax transmission receipts using a non-authenticated
	// SMTP server. The server's name and port are defined in the FAX_RECEIPTS_CONFIGW (section
	// 2.2.47) structure.
	SMTPAuthOptionsAnonymous SMTPAuthOptions = 0
	// FAX_SMTP_AUTH_BASIC: The server will send fax transmission receipts using a basic
	// (plain text) authenticated SMTP server. The server's name, port, user name, and password
	// are defined in the FAX_RECEIPTS_CONFIGW.
	SMTPAuthOptionsBasic SMTPAuthOptions = 1
	// FAX_SMTP_AUTH_NTLM: The server will send fax transmission receipts using an NTLM-authenticated
	// SMTP server. The server's name, port, user name, and password are defined in the
	// FAX_RECEIPTS_CONFIGW.
	SMTPAuthOptionsNTLM SMTPAuthOptions = 2
)

func (SMTPAuthOptions) String 

func (o SMTPAuthOptions) String() string

type ServerActivity 

type ServerActivity struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size
	// of the structure, in bytes. This value MUST be 36 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// dwIncomingMessages: A DWORD that indicates the number of messages currently being
	// received by the fax server. This variable MAY also be set to the count of the number
	// of incoming messages that were successfully received and are currently being routed
	// using an inbound routing method. If the routing fails, the incoming job SHOULD be
	// marked for a routing retry and the dwRoutingMessages member used to count this job
	// when the routing restarts. If this value is nonzero, stopping the server MAY result
	// in the loss of incoming messages.
	IncomingMessages uint32 `idl:"name:dwIncomingMessages" json:"incoming_messages"`
	// dwRoutingMessages: A DWORD that indicates the number of incoming messages being rerouted
	// after a routing failure.
	RoutingMessages uint32 `idl:"name:dwRoutingMessages" json:"routing_messages"`
	// dwOutgoingMessages: A DWORD that indicates the number of messages currently being
	// sent by the fax server. If this value is nonzero, stopping the server MAY result
	// in the loss of outgoing messages.
	OutgoingMessages uint32 `idl:"name:dwOutgoingMessages" json:"outgoing_messages"`
	// dwDelegatedOutgoingMessages: A DWORD that indicates the number of messages currently
	// being sent by a Fax Service Provider on behalf of the fax server. The fax server
	// is not currently sending these messages.
	DelegatedOutgoingMessages uint32 `idl:"name:dwDelegatedOutgoingMessages" json:"delegated_outgoing_messages"`
	// dwQueuedMessages: A DWORD that indicates the number of outgoing messages waiting
	// to be processed in the server's fax queue.
	QueuedMessages uint32 `idl:"name:dwQueuedMessages" json:"queued_messages"`
	// dwErrorEvents: A DWORD that indicates the number of error entries added to the system
	// event log since the last time the fax server was started.
	ErrorEvents uint32 `idl:"name:dwErrorEvents" json:"error_events"`
	// dwWarningEvents: A DWORD that indicates the number of warning entries added to the
	// system event log since the last time the fax server was started.
	WarningEvents uint32 `idl:"name:dwWarningEvents" json:"warning_events"`
	// dwInformationEvents: A DWORD that indicates the number of information entries added
	// to the system event log since the last time the fax server was started.
	InformationEvents uint32 `idl:"name:dwInformationEvents" json:"information_events"`
}

ServerActivity structure represents FAX_SERVER_ACTIVITY RPC structure.

The _FAX_SERVER_ACTIVITY data type is the custom-marshaled variant of the FAX_SERVER_ACTIVITY data structure described in section 2.2.19. The _FAX_SERVER_ACTIVITY defines information about the server's fax queue activity and the events reported by the fax server. This structure is used as a union field of the FAX_EVENT_EX (section 2.2.67) and FAX_EVENT_EX_1 (section 2.2.68) structures.

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (36 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

The FAX_SERVER_ACTIVITY structure defines information about the server's fax queue activity and the events reported by the fax server. This structure is used as an argument for FAX_GetServerActivity (section 3.1.4.1.61).

func (*ServerActivity) MarshalNDR 

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

func (*ServerActivity) UnmarshalNDR 

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

type Service 

type Service dcetypes.ContextHandle

Service structure represents RPC_FAX_SVC_HANDLE RPC structure.

func (*Service) ContextHandle 

func (o *Service) ContextHandle() *dcetypes.ContextHandle

func (*Service) MarshalNDR 

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

func (*Service) UnmarshalNDR 

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

type Time 

type Time struct {
	// Hour: A 16-bit unsigned integer that holds the current hour. This value MUST be between
	// 0 and 23 inclusive.
	Hour uint16 `idl:"name:Hour" json:"hour"`
	// Minute: A 16-bit unsigned integer that holds the current minute. This value MUST
	// be between 0 and 59 inclusive.
	Minute uint16 `idl:"name:Minute" json:"minute"`
}

Time structure represents FAX_TIME RPC structure.

The _FAX_TIME data type is the custom marshaled variant of the FAX_TIME (section 2.2.61) data structure. The _FAX_TIME is used in FAX_GENERAL_CONFIG (section 2.2.31) data type and the custom marshaled types _FAX_CONFIGURATIONW (section 2.2.29) and _FAX_OUTBOX_CONFIG (section 2.2.17).

This data structure is custom marshaled as follows, and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion                                                                                                                 |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

The FAX_TIME structure represents a time, using individual members for the current hour and minute. The time is expressed in Coordinated Universal Time (UTC). This structure is used in _FAX_CONFIGURATIONW (section 2.2.29), _FAX_OUTBOX_CONFIG (section 2.2.17), FAX_GENERAL_CONFIG (section 2.2.31) structures.

func (*Time) MarshalNDR 

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

func (*Time) UnmarshalNDR 

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

type Version 

type Version struct {
	// dwSizeOfStruct: A DWORD ([MS-DTYP] section 2.2.9) value that holds the total size
	// of the structure, in bytes. This value MUST be 20 bytes.
	StructureSize uint32 `idl:"name:dwSizeOfStruct" json:"structure_size"`
	// bValid: A Boolean value indicating the validity of the version information returned.
	Valid bool `idl:"name:bValid" json:"valid"`
	// wMajorVersion: A WORD containing the major version number of the fax server component.
	MajorVersion uint16 `idl:"name:wMajorVersion" json:"major_version"`
	// wMinorVersion: A WORD containing the minor version number of the fax server component.
	MinorVersion uint16 `idl:"name:wMinorVersion" json:"minor_version"`
	// wMajorBuildNumber: A WORD containing the major build number of the fax server component.
	MajorBuildNumber uint16 `idl:"name:wMajorBuildNumber" json:"major_build_number"`
	// wMinorBuildNumber: A WORD containing the minor build number of the fax server component.
	MinorBuildNumber uint16 `idl:"name:wMinorBuildNumber" json:"minor_build_number"`
	// dwFlags: A DWORD that MUST contain one of the following values.
	//
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	|                                    |                                                                                  |
	//	|             VALUE/CODE             |                                     MEANING                                      |
	//	|                                    |                                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| 0x00000000                         | Indicates that the server component was built in release mode. Note  If built in |
	//	|                                    | release mode, this value MUST be zero, which is the default.                     |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| FAX_VER_FLAG_CHECKED 0x00000001    | Indicates that the server component was built in debug mode.                     |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	//	| FAX_VER_FLAG_EVALUATION 0x00000002 | Indicates that the server component was built for evaluation purposes. Reserved  |
	//	|                                    | for future use.                                                                  |
	//	+------------------------------------+----------------------------------------------------------------------------------+
	Flags uint32 `idl:"name:dwFlags" json:"flags"`
}

Version structure represents FAX_VERSION RPC structure.

The _FAX_VERSION structure is the custom-marshaled variant of the FAX_VERSION (section 2.2.22) structure. The _FAX_VERSION contains the same information about the version of the fax server components as contained in the FAX_VERSION. The _FAX_VERSION is embedded in the FAX_ROUTING_EXTENSION_INFO (section 2.2.49) and FAX_DEVICE_PROVIDER_INFO (section 2.2.30) structures.

This data structure is custom marshaled as follows and uses the custom-marshaling rules defined in section 2.2.1. 

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 3 | 1 |
|   |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |   |   |   |   |   |   |   |   | 0 |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| Fixed_Portion (20 bytes)                                                                                                      |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| ...                                                                                                                           |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

The FAX_VERSION structure contains information about the version of the fax server components. This structure is used by FAX_GetVersion (section 3.1.4.1.64).

func (*Version) MarshalNDR 

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

func (*Version) UnmarshalNDR 

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

Source Files

View all Source files

Directories

Path Synopsis
fax
v4
faxclient
v3
faxobs
v4

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.