← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libfreerdp-utils/wait_obj.c

  • Committer: Package Import Robot
  • Author(s): Iain Lane
  • Date: 2014-11-11 12:20:50 UTC
  • mfrom: (1.1.9) (9.1.17 sid)
  • Revision ID: package-import@ubuntu.com-20141111122050-wyr8hrnwco9fcmum
Tags: 1.1.0~git20140921.1.440916e+dfsg1-2ubuntu1
* Merge with Debian unstable, remaining changes
  - Disable ffmpeg support
* Disable gstreamer support, this relies on gstreamer 0.10 and we don't want
  to add any more deps on that.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libfreerdp-utils/wait_obj.c
1
 
/**
2
 
 * FreeRDP: A Remote Desktop Protocol client.
3
 
 * Virtual Channel Manager
4
 
 *
5
 
 * Copyright 2009-2011 Jay Sorg
6
 
 *
7
 
 * Licensed under the Apache License, Version 2.0 (the "License");
8
 
 * you may not use this file except in compliance with the License.
9
 
 * You may obtain a copy of the License at
10
 
 *
11
 
 *     http://www.apache.org/licenses/LICENSE-2.0
12
 
 *
13
 
 * Unless required by applicable law or agreed to in writing, software
14
 
 * distributed under the License is distributed on an "AS IS" BASIS,
15
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
 
 * See the License for the specific language governing permissions and
17
 
 * limitations under the License.
18
 
 */
19
 
 
20
 
#include "config.h"
21
 
#include <stdio.h>
22
 
#include <stdlib.h>
23
 
#include <string.h>
24
 
#include <freerdp/utils/memory.h>
25
 
#include <freerdp/utils/wait_obj.h>
26
 
 
27
 
#ifndef _WIN32
28
 
#include <sys/time.h>
29
 
#else
30
 
#include <winsock2.h>
31
 
#endif
32
 
 
33
 
#ifdef HAVE_UNISTD_H
34
 
#include <unistd.h>
35
 
#endif
36
 
 
37
 
struct wait_obj
38
 
{
39
 
#ifdef _WIN32
40
 
        HANDLE event;
41
 
#else
42
 
        int pipe_fd[2];
43
 
#endif
44
 
        int attached;
45
 
};
46
 
 
47
 
struct wait_obj*
48
 
wait_obj_new(void)
49
 
{
50
 
        struct wait_obj* obj;
51
 
 
52
 
        obj = xnew(struct wait_obj);
53
 
 
54
 
        obj->attached = 0;
55
 
#ifdef _WIN32
56
 
        obj->event = CreateEvent(NULL, TRUE, FALSE, NULL);
57
 
#else
58
 
        obj->pipe_fd[0] = -1;
59
 
        obj->pipe_fd[1] = -1;
60
 
        if (pipe(obj->pipe_fd) < 0)
61
 
        {
62
 
                printf("wait_obj_new: pipe failed\n");
63
 
                xfree(obj);
64
 
                return NULL;
65
 
        }
66
 
#endif
67
 
 
68
 
        return obj;
69
 
}
70
 
 
71
 
struct wait_obj* wait_obj_new_with_fd(void* fd)
72
 
{
73
 
        struct wait_obj* obj;
74
 
 
75
 
        obj = xnew(struct wait_obj);
76
 
 
77
 
        obj->attached = 1;
78
 
#ifdef _WIN32
79
 
        obj->event = fd;
80
 
#else
81
 
        obj->pipe_fd[0] = (int)(long)fd;
82
 
        obj->pipe_fd[1] = -1;
83
 
#endif
84
 
 
85
 
        return obj;
86
 
}
87
 
 
88
 
void
89
 
wait_obj_free(struct wait_obj* obj)
90
 
{
91
 
        if (obj)
92
 
        {
93
 
 
94
 
                if (obj->attached == 0)
95
 
                {
96
 
#ifdef _WIN32
97
 
                        if (obj->event)
98
 
                        {
99
 
                                CloseHandle(obj->event);
100
 
                                obj->event = NULL;
101
 
                        }
102
 
#else
103
 
                        if (obj->pipe_fd[0] != -1)
104
 
                        {
105
 
                                close(obj->pipe_fd[0]);
106
 
                                obj->pipe_fd[0] = -1;
107
 
                        }
108
 
                        if (obj->pipe_fd[1] != -1)
109
 
                        {
110
 
                                close(obj->pipe_fd[1]);
111
 
                                obj->pipe_fd[1] = -1;
112
 
                        }
113
 
#endif
114
 
                }
115
 
 
116
 
                xfree(obj);
117
 
        }
118
 
}
119
 
 
120
 
int
121
 
wait_obj_is_set(struct wait_obj* obj)
122
 
{
123
 
#ifdef _WIN32
124
 
        return (WaitForSingleObject(obj->event, 0) == WAIT_OBJECT_0);
125
 
#else
126
 
        fd_set rfds;
127
 
        int num_set;
128
 
        struct timeval time;
129
 
 
130
 
        FD_ZERO(&rfds);
131
 
        FD_SET(obj->pipe_fd[0], &rfds);
132
 
        memset(&time, 0, sizeof(time));
133
 
        num_set = select(obj->pipe_fd[0] + 1, &rfds, 0, 0, &time);
134
 
        return (num_set == 1);
135
 
#endif
136
 
}
137
 
 
138
 
void
139
 
wait_obj_set(struct wait_obj* obj)
140
 
{
141
 
#ifdef _WIN32
142
 
        SetEvent(obj->event);
143
 
#else
144
 
        int len;
145
 
 
146
 
        if (wait_obj_is_set(obj))
147
 
                return;
148
 
        len = write(obj->pipe_fd[1], "sig", 4);
149
 
        if (len != 4)
150
 
                printf("wait_obj_set: error\n");
151
 
#endif
152
 
}
153
 
 
154
 
void
155
 
wait_obj_clear(struct wait_obj* obj)
156
 
{
157
 
#ifdef _WIN32
158
 
        ResetEvent(obj->event);
159
 
#else
160
 
        int len;
161
 
 
162
 
        while (wait_obj_is_set(obj))
163
 
        {
164
 
                len = read(obj->pipe_fd[0], &len, 4);
165
 
                if (len != 4)
166
 
                        printf("wait_obj_clear: error\n");
167
 
        }
168
 
#endif
169
 
}
170
 
 
171
 
int
172
 
wait_obj_select(struct wait_obj** listobj, int numobj, int timeout)
173
 
{
174
 
#ifndef _WIN32
175
 
        int max;
176
 
        int sock;
177
 
        int index;
178
 
#endif
179
 
        fd_set fds;
180
 
        int status;
181
 
        struct timeval time;
182
 
        struct timeval* ptime;
183
 
 
184
 
        ptime = 0;
185
 
        if (timeout >= 0)
186
 
        {
187
 
                time.tv_sec = timeout / 1000;
188
 
                time.tv_usec = (timeout * 1000) % 1000000;
189
 
                ptime = &time;
190
 
        }
191
 
 
192
 
#ifndef _WIN32
193
 
        max = 0;
194
 
        FD_ZERO(&fds);
195
 
        if (listobj)
196
 
        {
197
 
                for (index = 0; index < numobj; index++)
198
 
                {
199
 
                        sock = listobj[index]->pipe_fd[0];
200
 
                        FD_SET(sock, &fds);
201
 
 
202
 
                        if (sock > max)
203
 
                                max = sock;
204
 
                }
205
 
        }
206
 
        status = select(max + 1, &fds, 0, 0, ptime);
207
 
#else
208
 
        status = select(0, &fds, 0, 0, ptime);
209
 
#endif
210
 
 
211
 
        return status;
212
 
}
213
 
 
214
 
void wait_obj_get_fds(struct wait_obj* obj, void** fds, int* count)
215
 
{
216
 
#ifdef _WIN32
217
 
        fds[*count] = (void*) obj->event;
218
 
#else
219
 
        if (obj->pipe_fd[0] == -1)
220
 
                return;
221
 
 
222
 
        fds[*count] = (void*)(long) obj->pipe_fd[0];
223
 
#endif
224
 
        (*count)++;
225
 
}