← Back to branch summary

~ubuntu-branches/ubuntu/vivid/freerdp/vivid

« back to all changes in this revision

Viewing changes to server/Windows/wf_interface.c

  • Committer: Package Import Robot
  • Author(s): Iain Lane
  • Date: 2014-11-11 12:20:50 UTC
  • mfrom: (1.2.5)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20141111122050-7z628f4ab38qxad5
Tags: upstream-1.1.0~git20140921.1.440916e+dfsg1
Import upstream version 1.1.0~git20140921.1.440916e+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/Windows/wf_interface.c
 
1
/**
 
2
 * FreeRDP: A Remote Desktop Protocol Implementation
 
3
 * FreeRDP Windows Server
 
4
 *
 
5
 * Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 
6
 * Copyright 2012 Corey Clayton <can.of.tuna@gmail.com>
 
7
 *
 
8
 * Licensed under the Apache License, Version 2.0 (the "License");
 
9
 * you may not use this file except in compliance with the License.
 
10
 * You may obtain a copy of the License at
 
11
 *
 
12
 *     http://www.apache.org/licenses/LICENSE-2.0
 
13
 *
 
14
 * Unless required by applicable law or agreed to in writing, software
 
15
 * distributed under the License is distributed on an "AS IS" BASIS,
 
16
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
17
 * See the License for the specific language governing permissions and
 
18
 * limitations under the License.
 
19
 */
 
20
 
 
21
#ifdef HAVE_CONFIG_H
 
22
#include "config.h"
 
23
#endif
 
24
 
 
25
 
 
26
#include <winpr/tchar.h>
 
27
#include <winpr/windows.h>
 
28
#include <freerdp/utils/tcp.h>
 
29
#include <freerdp\listener.h>
 
30
 
 
31
#include "wf_peer.h"
 
32
#include "wf_settings.h"
 
33
#include "wf_info.h"
 
34
 
 
35
#include "wf_interface.h"
 
36
 
 
37
cbCallback cbEvent;
 
38
 
 
39
int get_screen_info(int id, _TCHAR* name, int* width, int* height, int* bpp)
 
40
{
 
41
        DISPLAY_DEVICE dd;
 
42
 
 
43
        memset(&dd, 0, sizeof(DISPLAY_DEVICE));
 
44
        dd.cb = sizeof(DISPLAY_DEVICE);
 
45
 
 
46
        if (EnumDisplayDevices(NULL, id, &dd, 0) != 0)
 
47
        {
 
48
                HDC dc;
 
49
 
 
50
                if (name != NULL)
 
51
                        _stprintf(name, _T("%s (%s)"), dd.DeviceName, dd.DeviceString);
 
52
 
 
53
                dc = CreateDC(dd.DeviceName, NULL, NULL, NULL);
 
54
                *width = GetDeviceCaps(dc, HORZRES);
 
55
                *height = GetDeviceCaps(dc, VERTRES);
 
56
                *bpp = GetDeviceCaps(dc, BITSPIXEL);
 
57
                //ReleaseDC(NULL, dc);
 
58
                DeleteDC(dc);
 
59
 
 
60
        }
 
61
        else
 
62
        {
 
63
                return 0;
 
64
        }
 
65
 
 
66
        return 1;
 
67
}
 
68
 
 
69
void set_screen_id(int id)
 
70
{
 
71
        wfInfo* wfi;
 
72
 
 
73
        wfi = wf_info_get_instance();
 
74
        wfi->screenID = id;
 
75
 
 
76
        return;
 
77
}
 
78
 
 
79
DWORD WINAPI wf_server_main_loop(LPVOID lpParam)
 
80
{
 
81
        int i, fds;
 
82
        int rcount;
 
83
        int max_fds;
 
84
        void* rfds[32];
 
85
        fd_set rfds_set;
 
86
        freerdp_listener* instance;
 
87
        wfInfo* wfi;
 
88
 
 
89
        wfi = wf_info_get_instance();
 
90
        wfi->force_all_disconnect = FALSE;
 
91
 
 
92
        ZeroMemory(rfds, sizeof(rfds));
 
93
        instance = (freerdp_listener*) lpParam;
 
94
 
 
95
        while(wfi->force_all_disconnect == FALSE)
 
96
        {
 
97
                rcount = 0;
 
98
 
 
99
                if (instance->GetFileDescriptor(instance, rfds, &rcount) != TRUE)
 
100
                {
 
101
                        printf("Failed to get FreeRDP file descriptor\n");
 
102
                        break;
 
103
                }
 
104
 
 
105
                max_fds = 0;
 
106
                FD_ZERO(&rfds_set);
 
107
 
 
108
                for (i = 0; i < rcount; i++)
 
109
                {
 
110
                        fds = (int)(long)(rfds[i]);
 
111
 
 
112
                        if (fds > max_fds)
 
113
                                max_fds = fds;
 
114
 
 
115
                        FD_SET(fds, &rfds_set);
 
116
                }
 
117
 
 
118
                if (max_fds == 0)
 
119
                        break;
 
120
 
 
121
                
 
122
                select(max_fds + 1, &rfds_set, NULL, NULL, NULL);
 
123
 
 
124
                if (instance->CheckFileDescriptor(instance) != TRUE)
 
125
                {
 
126
                        printf("Failed to check FreeRDP file descriptor\n");
 
127
                        break;
 
128
                }
 
129
        }
 
130
 
 
131
        printf("wf_server_main_loop terminating\n");
 
132
 
 
133
        instance->Close(instance);
 
134
 
 
135
        return 0;
 
136
}
 
137
 
 
138
BOOL wfreerdp_server_start(wfServer* server)
 
139
{
 
140
        freerdp_listener* instance;
 
141
 
 
142
        server->instance = freerdp_listener_new();
 
143
        server->instance->PeerAccepted = wf_peer_accepted;
 
144
        instance = server->instance;
 
145
 
 
146
        wf_settings_read_dword(HKEY_LOCAL_MACHINE, _T("Software\\FreeRDP\\Server"), _T("DefaultPort"), &server->port);
 
147
 
 
148
        if (instance->Open(instance, NULL, (UINT16) server->port))
 
149
        {
 
150
                server->thread = CreateThread(NULL, 0, wf_server_main_loop, (void*) instance, 0, NULL);
 
151
                return TRUE;
 
152
        }
 
153
 
 
154
        return FALSE;
 
155
}
 
156
 
 
157
BOOL wfreerdp_server_stop(wfServer* server)
 
158
{
 
159
        wfInfo* wfi;
 
160
 
 
161
        wfi = wf_info_get_instance();
 
162
 
 
163
        printf("Stopping server\n");
 
164
        wfi->force_all_disconnect = TRUE;
 
165
        server->instance->Close(server->instance);
 
166
        return TRUE;
 
167
}
 
168
 
 
169
wfServer* wfreerdp_server_new()
 
170
{
 
171
        wfServer* server;
 
172
 
 
173
        server = (wfServer*) malloc(sizeof(wfServer));
 
174
        ZeroMemory(server, sizeof(wfServer));
 
175
 
 
176
        freerdp_wsa_startup();
 
177
 
 
178
        if (server)
 
179
        {
 
180
                server->port = 3389;
 
181
        }
 
182
 
 
183
        cbEvent = NULL;
 
184
 
 
185
        return server;
 
186
}
 
187
 
 
188
void wfreerdp_server_free(wfServer* server)
 
189
{
 
190
        if (server)
 
191
        {
 
192
                free(server);
 
193
        }
 
194
 
 
195
        freerdp_wsa_cleanup();
 
196
}
 
197
 
 
198
 
 
199
FREERDP_API BOOL wfreerdp_server_is_running(wfServer* server)
 
200
{
 
201
        DWORD tStatus;
 
202
        BOOL bRet;
 
203
 
 
204
        bRet = GetExitCodeThread(server->thread, &tStatus);
 
205
        if (bRet == 0)
 
206
        {
 
207
                printf("Error in call to GetExitCodeThread\n");
 
208
                return FALSE;
 
209
        }
 
210
 
 
211
        if (tStatus == STILL_ACTIVE)
 
212
                return TRUE;
 
213
        return FALSE;
 
214
}
 
215
 
 
216
FREERDP_API UINT32 wfreerdp_server_num_peers()
 
217
{
 
218
        wfInfo* wfi;
 
219
 
 
220
        wfi = wf_info_get_instance();
 
221
        return wfi->peerCount;
 
222
}
 
223
 
 
224
FREERDP_API UINT32 wfreerdp_server_get_peer_hostname(int pId, wchar_t * dstStr)
 
225
{
 
226
        wfInfo* wfi;
 
227
        freerdp_peer* peer;
 
228
 
 
229
        wfi = wf_info_get_instance();
 
230
        peer = wfi->peers[pId];
 
231
 
 
232
        
 
233
        if (peer)
 
234
        {
 
235
                UINT32 sLen;
 
236
 
 
237
                sLen = strnlen_s(peer->hostname, 50);
 
238
                swprintf(dstStr, 50, L"%hs", peer->hostname);
 
239
                return sLen;
 
240
        }
 
241
        else
 
242
        {
 
243
                printf("nonexistent peer id=%d\n", pId);
 
244
                return 0;
 
245
        }
 
246
 
 
247
}
 
248
 
 
249
FREERDP_API BOOL wfreerdp_server_peer_is_local(int pId)
 
250
{
 
251
        wfInfo* wfi;
 
252
        freerdp_peer* peer;
 
253
 
 
254
        wfi = wf_info_get_instance();
 
255
        peer = wfi->peers[pId];
 
256
 
 
257
        
 
258
        if (peer)
 
259
        {
 
260
                return peer->local;
 
261
        }
 
262
        else
 
263
        {
 
264
                return FALSE;
 
265
        }
 
266
}
 
267
FREERDP_API BOOL wfreerdp_server_peer_is_connected(int pId)
 
268
{
 
269
        wfInfo* wfi;
 
270
        freerdp_peer* peer;
 
271
 
 
272
        wfi = wf_info_get_instance();
 
273
        peer = wfi->peers[pId];
 
274
 
 
275
        
 
276
        if (peer)
 
277
        {
 
278
                return peer->connected;
 
279
        }
 
280
        else
 
281
        {
 
282
                return FALSE;
 
283
        }
 
284
}
 
285
 
 
286
FREERDP_API BOOL wfreerdp_server_peer_is_activated(int pId)
 
287
{
 
288
        wfInfo* wfi;
 
289
        freerdp_peer* peer;
 
290
 
 
291
        wfi = wf_info_get_instance();
 
292
        peer = wfi->peers[pId];
 
293
 
 
294
        
 
295
        if (peer)
 
296
        {
 
297
                return peer->activated;
 
298
        }
 
299
        else
 
300
        {
 
301
                return FALSE;
 
302
        }
 
303
}
 
304
 
 
305
FREERDP_API BOOL wfreerdp_server_peer_is_authenticated(int pId)
 
306
{
 
307
        wfInfo* wfi;
 
308
        freerdp_peer* peer;
 
309
 
 
310
        wfi = wf_info_get_instance();
 
311
        peer = wfi->peers[pId];
 
312
 
 
313
        
 
314
        if (peer)
 
315
        {
 
316
                return peer->authenticated;
 
317
        }
 
318
        else
 
319
        {
 
320
                return FALSE;
 
321
        }
 
322
}
 
323
 
 
324
FREERDP_API void wfreerdp_server_register_callback_event(cbCallback cb)
 
325
{
 
326
        cbEvent = cb;
 
327
}
 
328
 
 
329
void wfreerdp_server_peer_callback_event(int pId, UINT32 eType)
 
330
{
 
331
        if (cbEvent)
 
332
                cbEvent(pId, eType);
 
333
}
 
334