FreeRDP/libfreerdp/core/autodetect.h

54 lines
1.9 KiB
C
Raw Normal View History

2014-01-24 07:23:47 +04:00
/**
* FreeRDP: A Remote Desktop Protocol Implementation
* Auto-Detect PDUs
*
* Copyright 2014 Dell Software <Mike.McDonald@software.dell.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_LIB_CORE_AUTODETECT_H
#define FREERDP_LIB_CORE_AUTODETECT_H
2014-01-24 07:23:47 +04:00
#include "rdp.h"
#include <freerdp/freerdp.h>
#include <freerdp/autodetect.h>
#include <freerdp/log.h>
#include <freerdp/api.h>
2014-01-24 07:23:47 +04:00
#include <winpr/stream.h>
#include <winpr/sysinfo.h>
#include "state.h"
FREERDP_LOCAL void autodetect_free(rdpAutoDetect* autodetect);
WINPR_ATTR_MALLOC(autodetect_free, 1)
FREERDP_LOCAL rdpAutoDetect* autodetect_new(rdpContext* context);
FREERDP_LOCAL state_run_t autodetect_recv_request_packet(rdpAutoDetect* autodetect,
RDP_TRANSPORT_TYPE transport, wStream* s);
FREERDP_LOCAL state_run_t autodetect_recv_response_packet(rdpAutoDetect* autodetect,
RDP_TRANSPORT_TYPE transport, wStream* s);
core/autodetect: Rework server side API to be closer to documentation The current state of the autodetect API for the server side does not include all allowed scenarios where the network autodetection can be used. This for example includes the connect-time autodetection, as the related calls are hidden inside FreeRDP, and not exposed as public API. In order to avoid duplicate send methods, check the state of the connection sequence. If the connection sequence is not yet done, use the connect-time request types. Otherwise, use the continuous request types. The Bandwidth Measure Payload PDU is a little special case, as it is only allowed to be sent during the connection sequence. To ensure this, add an assertion in its sending method. Also fix the handling for the Network Characteristics Sync PDU: Previously, after parsing the PDU data, the read data was just sent again to the client, which is wrong. To fix this issue, introduce a callback for this client-to-server PDU, so that the actual server implementation can hook up its own handling for this PDU. Depending on the situation, the server side may want to discard or use the retrieved data here. Moreover, decouple the send-handling for the Network Characteristics Result PDU from the local autodetect variables. Currently, these variables are shared between the send and receive methods. This leads to access problems, where the server side, wants to use a different thread to send the autodetect PDU, as the receive handler may receive an autodetect PDU and overwrite these values with possible nonsense values. This is especially the case with RTT response PDUs, as the written netCharAverageRTT and netCharBaseRTT values are only correct, when only one RTTRequest happens at a time and no stray RTTResponses are received.
2023-04-09 10:59:34 +03:00
FREERDP_LOCAL FREERDP_AUTODETECT_STATE autodetect_get_state(rdpAutoDetect* autodetect);
2019-11-06 17:24:51 +03:00
FREERDP_LOCAL void autodetect_register_server_callbacks(rdpAutoDetect* autodetect);
core/autodetect: Allow overriding connect-time autodetection handling Currently, FreeRDP-based server implementations can do connect-time autodetection. However, without having any control over it. In order to be able to override the default connect-time autodetection handling, introduce three new states for the state machine of the connection sequence and two new callbacks for the autodetect handling. These are: - CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_BEGIN - CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_IN_PROGRESS - CONNECTION_STATE_CONNECT_TIME_AUTO_DETECT_END - OnConnectTimeAutoDetectBegin() - OnConnectTimeAutoDetectProgress() The END state is pretty simple: When the autodetection is finished and the autodetect state is FREERDP_AUTODETECT_STATE_COMPLETE, transition into the next state of the connection sequence. The BEGIN state is entered, when capability-wise network autodetection is available. In this state, the OnConnectTimeAutoDetectBegin callback is called, the server implementation may initialize any related handling here. If the server implementation determines, that no further handling is required, it can end the autodetection phase by returning FREERDP_AUTODETECT_STATE_COMPLETE. If not, and an autodetection request is sent, it returns FREERDP_AUTODETECT_STATE_REQUEST. The state machine of the connection sequence will then switch into the IN_PROGRESS state. In the IN_PROGRESS state, any incoming PDU is handled first, then the OnConnectTimeAutoDetectProgress callback is called. Like in the BEGIN state, the return value will determine, whether the state machine of the connection sequence goes into the END state or goes into (or rather stays) in the IN_PROGRESS state.
2023-04-09 19:34:56 +03:00
FREERDP_LOCAL void autodetect_on_connect_time_auto_detect_begin(rdpAutoDetect* autodetect);
FREERDP_LOCAL void autodetect_on_connect_time_auto_detect_progress(rdpAutoDetect* autodetect);
#define AUTODETECT_TAG FREERDP_TAG("core.autodetect")
2014-01-24 07:23:47 +04:00
#endif /* FREERDP_LIB_CORE_AUTODETECT_H */