← Back to branch summary

~ubuntu-branches/ubuntu/wily/freerdp/wily-proposed

« back to all changes in this revision

Viewing changes to channels/drdynvc/pnpdr/pnpdr_main.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt, Jeremy Bicha, Jean-Louis Dupond, Martin Pitt
  • Date: 2012-01-31 10:02:14 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120131100214-jaok3uwvni7sqxth
Tags: 1.0.0-0git1
http://bugs.debian.org/647498
Upload current Debian packaging git to get this rolling for precise.

[ Jeremy Bicha ]
* New upstream release. Closes: #647498.
* Updated symbols and bumped soname
* debian/control:
  - Added new build dependencies
  - Bump Standards-Version to 3.9.2
* debian/source/format: Set to 3.0 (quilt)
* debian/rules: Turn on strict symbols checking
* debian/watch: Watch github

[ Jean-Louis Dupond ]
* debian/control: Updated homepage
* debian/copyright: Reflect upstream switch to the Apache license

[ Martin Pitt ]
* debian/libfreerdp0.symbols: Fix version number, should
  be 1.0~beta5, not 1.0-beta5.
* debian/control: Add libavcodec-dev build dependency, upstream build system
  checks for that. Thanks Jean-Louis Dupond!

Show diffs side-by-side

added added

removed removed

Lines of Context:
channels/drdynvc/pnpdr/pnpdr_main.c
1
 
/*
2
 
   Copyright (c) 2010 Vic Lee
3
 
 
4
 
   Permission is hereby granted, free of charge, to any person obtaining a
5
 
   copy of this software and associated documentation files (the "Software"),
6
 
   to deal in the Software without restriction, including without limitation
7
 
   the rights to use, copy, modify, merge, publish, distribute, sublicense,
8
 
   and/or sell copies of the Software, and to permit persons to whom the
9
 
   Software is furnished to do so, subject to the following conditions:
10
 
 
11
 
   The above copyright notice and this permission notice shall be included
12
 
   in all copies or substantial portions of the Software.
13
 
 
14
 
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15
 
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16
 
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17
 
   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18
 
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19
 
   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20
 
   DEALINGS IN THE SOFTWARE.
21
 
 
22
 
*/
23
 
 
24
 
#include <stdio.h>
25
 
#include <stdlib.h>
26
 
#include <string.h>
27
 
#include "drdynvc_types.h"
28
 
 
29
 
#define IRPDR_ID_VERSION            0x00000065
30
 
#define IRPDR_ID_REDIRECT_DEVICES   0x00000066
31
 
#define IRPDR_ID_SERVER_LOGON       0x00000067
32
 
#define IRPDR_ID_UNREDIRECT_DEVICE  0x00000068
33
 
 
34
 
typedef struct _PNPDR_LISTENER_CALLBACK PNPDR_LISTENER_CALLBACK;
35
 
struct _PNPDR_LISTENER_CALLBACK
36
 
{
37
 
        IWTSListenerCallback iface;
38
 
 
39
 
        IWTSPlugin * plugin;
40
 
        IWTSVirtualChannelManager * channel_mgr;
41
 
};
42
 
 
43
 
typedef struct _PNPDR_CHANNEL_CALLBACK PNPDR_CHANNEL_CALLBACK;
44
 
struct _PNPDR_CHANNEL_CALLBACK
45
 
{
46
 
        IWTSVirtualChannelCallback iface;
47
 
 
48
 
        IWTSPlugin * plugin;
49
 
        IWTSVirtualChannelManager * channel_mgr;
50
 
        IWTSVirtualChannel * channel;
51
 
};
52
 
 
53
 
typedef struct _PNPDR_PLUGIN PNPDR_PLUGIN;
54
 
struct _PNPDR_PLUGIN
55
 
{
56
 
        IWTSPlugin iface;
57
 
 
58
 
        PNPDR_LISTENER_CALLBACK * listener_callback;
59
 
};
60
 
 
61
 
static int
62
 
pnpdr_process_version(IWTSVirtualChannelCallback * pChannelCallback,
63
 
        char * data, uint32 data_size)
64
 
{
65
 
        PNPDR_CHANNEL_CALLBACK * callback = (PNPDR_CHANNEL_CALLBACK *) pChannelCallback;
66
 
        uint32 MajorVersion;
67
 
        uint32 MinorVersion;
68
 
        uint32 Capabilities;
69
 
        uint32 out_size;
70
 
        char * out_data;
71
 
 
72
 
        MajorVersion = GET_UINT32(data, 0);
73
 
        MinorVersion = GET_UINT32(data, 4);
74
 
        Capabilities = GET_UINT32(data, 8);
75
 
        LLOGLN(10, ("pnpdr_process_version: MajorVersion=%d MinorVersion=%d Capabilities=%d",
76
 
                MajorVersion, MinorVersion, Capabilities));
77
 
 
78
 
        out_size = 20;
79
 
        out_data = (char *) malloc(out_size);
80
 
        memset(out_data, 0, out_size);
81
 
        SET_UINT32(out_data, 0, out_size);
82
 
        SET_UINT32(out_data, 4, IRPDR_ID_VERSION);
83
 
        SET_UINT32(out_data, 8, MajorVersion);
84
 
        SET_UINT32(out_data, 12, MinorVersion);
85
 
        SET_UINT32(out_data, 16, Capabilities);
86
 
        callback->channel->Write(callback->channel, out_size, out_data, NULL);
87
 
        free(out_data);
88
 
 
89
 
        return 0;
90
 
}
91
 
 
92
 
static int
93
 
pnpdr_on_data_received(IWTSVirtualChannelCallback * pChannelCallback,
94
 
        uint32 cbSize,
95
 
        char * pBuffer)
96
 
{
97
 
        uint32 Size;
98
 
        uint32 PacketId;
99
 
        int error = 0;
100
 
 
101
 
        Size = GET_UINT32(pBuffer, 0);
102
 
        PacketId = GET_UINT32(pBuffer, 4);
103
 
        if (Size != cbSize)
104
 
        {
105
 
                LLOGLN(0, ("pnpdr_on_data_received: invalid size. cbSize=%d Size=%d", cbSize, Size));
106
 
                return 1;
107
 
        }
108
 
        LLOGLN(10, ("pnpdr_on_data_received: Size=%d PacketId=0x%X", Size, PacketId));
109
 
        switch (PacketId)
110
 
        {
111
 
                case IRPDR_ID_VERSION:
112
 
                        error = pnpdr_process_version(pChannelCallback, pBuffer + 8, Size - 8);
113
 
                        break;
114
 
                case IRPDR_ID_SERVER_LOGON:
115
 
                        LLOGLN(10, ("pnpdr_on_data_received: IRPDR_ID_SERVER_LOGON"));
116
 
                        break;
117
 
                default:
118
 
                        LLOGLN(0, ("pnpdr_on_data_received: unknown PacketId 0x%X", PacketId));
119
 
                        error = 1;
120
 
                        break;
121
 
        }
122
 
        return error;
123
 
}
124
 
 
125
 
static int
126
 
pnpdr_on_close(IWTSVirtualChannelCallback * pChannelCallback)
127
 
{
128
 
        LLOGLN(10, ("pnpdr_on_close:"));
129
 
        free(pChannelCallback);
130
 
        return 0;
131
 
}
132
 
 
133
 
static int
134
 
pnpdr_on_new_channel_connection(IWTSListenerCallback * pListenerCallback,
135
 
        IWTSVirtualChannel * pChannel,
136
 
        char * Data,
137
 
        int * pbAccept,
138
 
        IWTSVirtualChannelCallback ** ppCallback)
139
 
{
140
 
        PNPDR_LISTENER_CALLBACK * listener_callback = (PNPDR_LISTENER_CALLBACK *) pListenerCallback;
141
 
        PNPDR_CHANNEL_CALLBACK * callback;
142
 
 
143
 
        LLOGLN(10, ("pnpdr_on_new_channel_connection:"));
144
 
        callback = (PNPDR_CHANNEL_CALLBACK *) malloc(sizeof(PNPDR_CHANNEL_CALLBACK));
145
 
        callback->iface.OnDataReceived = pnpdr_on_data_received;
146
 
        callback->iface.OnClose = pnpdr_on_close;
147
 
        callback->plugin = listener_callback->plugin;
148
 
        callback->channel_mgr = listener_callback->channel_mgr;
149
 
        callback->channel = pChannel;
150
 
        *ppCallback = (IWTSVirtualChannelCallback *) callback;
151
 
        return 0;
152
 
}
153
 
 
154
 
static int
155
 
pnpdr_plugin_initialize(IWTSPlugin * pPlugin, IWTSVirtualChannelManager * pChannelMgr)
156
 
{
157
 
        PNPDR_PLUGIN * pnpdr = (PNPDR_PLUGIN *) pPlugin;
158
 
 
159
 
        LLOGLN(10, ("pnpdr_plugin_initialize:"));
160
 
        pnpdr->listener_callback = (PNPDR_LISTENER_CALLBACK *) malloc(sizeof(PNPDR_LISTENER_CALLBACK));
161
 
        memset(pnpdr->listener_callback, 0, sizeof(PNPDR_LISTENER_CALLBACK));
162
 
 
163
 
        pnpdr->listener_callback->iface.OnNewChannelConnection = pnpdr_on_new_channel_connection;
164
 
        pnpdr->listener_callback->plugin = pPlugin;
165
 
        pnpdr->listener_callback->channel_mgr = pChannelMgr;
166
 
        return pChannelMgr->CreateListener(pChannelMgr, "PNPDR", 0,
167
 
                (IWTSListenerCallback *) pnpdr->listener_callback, NULL);
168
 
}
169
 
 
170
 
static int
171
 
pnpdr_plugin_terminated(IWTSPlugin * pPlugin)
172
 
{
173
 
        PNPDR_PLUGIN * pnpdr = (PNPDR_PLUGIN *) pPlugin;
174
 
 
175
 
        LLOGLN(10, ("pnpdr_plugin_terminated:"));
176
 
        if (pnpdr->listener_callback)
177
 
                free(pnpdr->listener_callback);
178
 
        free(pnpdr);
179
 
        return 0;
180
 
}
181
 
 
182
 
int
183
 
DVCPluginEntry(IDRDYNVC_ENTRY_POINTS * pEntryPoints)
184
 
{
185
 
        PNPDR_PLUGIN * pnpdr;
186
 
 
187
 
        pnpdr = (PNPDR_PLUGIN *) malloc(sizeof(PNPDR_PLUGIN));
188
 
        memset(pnpdr, 0, sizeof(PNPDR_PLUGIN));
189
 
 
190
 
        pnpdr->iface.Initialize = pnpdr_plugin_initialize;
191
 
        pnpdr->iface.Connected = NULL;
192
 
        pnpdr->iface.Disconnected = NULL;
193
 
        pnpdr->iface.Terminated = pnpdr_plugin_terminated;
194
 
        return pEntryPoints->RegisterPlugin(pEntryPoints, (IWTSPlugin *) pnpdr);
195
 
}
196