1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/*
Copyright (C) 2009 Red Hat, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef RED_COMMON_H_
#define RED_COMMON_H_
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <glib.h>
#include <spice/macros.h>
#include <common/log.h>
#include <common/lz_common.h>
#include <common/marshaller.h>
#include <common/messages.h>
#include <common/draw.h>
#include <common/verify.h>
#include "spice.h"
#include "utils.h"
#include "sys-socket.h"
#define SPICE_UPCAST(type, ptr) \
(verify_expr(SPICE_OFFSETOF(type, base) == 0,SPICE_CONTAINEROF(ptr, type, base)))
SPICE_BEGIN_DECLS
void red_timer_start(SpiceTimer *timer, uint32_t ms);
void red_timer_cancel(SpiceTimer *timer);
void red_timer_remove(SpiceTimer *timer);
void red_watch_update_mask(SpiceWatch *watch, int event_mask);
void red_watch_remove(SpiceWatch *watch);
typedef struct SpiceCoreInterfaceInternal SpiceCoreInterfaceInternal;
struct SpiceCoreInterfaceInternal {
SpiceTimer *(*timer_add)(const SpiceCoreInterfaceInternal *iface, SpiceTimerFunc func, void *opaque);
SpiceWatch *(*watch_add)(const SpiceCoreInterfaceInternal *iface, int fd, int event_mask, SpiceWatchFunc func, void *opaque);
void (*channel_event)(const SpiceCoreInterfaceInternal *iface, int event, SpiceChannelEventInfo *info);
/* This structure is an adapter that allows us to use the same API to
* implement the core interface in a couple different ways. The first
* method is to use a public SpiceCoreInterface provided to us by the
* library user (for example, qemu). The second method is to implement the
* core interface functions using the glib event loop. In order to avoid
* global variables, each method needs to store additional data in this
* adapter structure. Instead of using a generic void* data parameter, we
* provide a bit more type-safety by using a union to store the type of
* data needed by each implementation.
*/
union {
GMainContext *main_context;
SpiceCoreInterface *public_interface;
};
};
extern const SpiceCoreInterfaceInternal event_loop_core;
extern const SpiceCoreInterfaceInternal core_interface_adapter;
typedef struct RedsState RedsState;
typedef struct GListIter {
GList *link;
GList *next;
} GListIter;
/* Iterate through a GList. Note that the iteration is "safe" meaning that the
* current item can be removed while the list is scanned. This is required as
* the code inside the loop in some cases can remove the element we are
* processing */
#define GLIST_FOREACH_GENERIC(_list, _iter, _type, _data, _dir) \
for (GListIter _iter = { .link = _list }; \
(_data = (_type *) (_iter.link ? _iter.link->data : NULL), \
_iter.next = (_iter.link ? _iter.link->_dir : NULL), \
_iter.link) != NULL; \
_iter.link = _iter.next)
#define GLIST_FOREACH(_list, _type, _data) \
GLIST_FOREACH_GENERIC(_list, G_PASTE(_iter_, __LINE__), _type, _data, next)
#define GLIST_FOREACH_REVERSED(_list, _type, _data) \
GLIST_FOREACH_GENERIC(_list, G_PASTE(_iter_, __LINE__), _type, _data, prev)
/* Helper to declare a GObject type
*
* @ModuleObjName type identifier like MyObject
* @module_obj_name method prefix like my_object (no need to add the
* underscore)
* @OBJ_NAME macro common part like MY_OBJECT
*/
#define SPICE_DECLARE_TYPE(ModuleObjName, module_obj_name, OBJ_NAME) \
typedef struct ModuleObjName ModuleObjName; \
typedef struct ModuleObjName ## Class ModuleObjName ## Class; \
typedef struct ModuleObjName ## Private ModuleObjName ## Private; \
GType module_obj_name ## _get_type(void) G_GNUC_CONST; \
static inline SPICE_GNUC_UNUSED ModuleObjName *G_PASTE(RED_,OBJ_NAME)(void *obj) \
{ return G_TYPE_CHECK_INSTANCE_CAST(obj, \
module_obj_name ## _get_type(), ModuleObjName); } \
static inline SPICE_GNUC_UNUSED \
ModuleObjName ## Class *G_PASTE(G_PASTE(RED_,OBJ_NAME),_CLASS)(void *klass) \
{ return G_TYPE_CHECK_CLASS_CAST(klass, \
module_obj_name ## _get_type(), ModuleObjName ## Class); } \
static inline SPICE_GNUC_UNUSED gboolean G_PASTE(RED_IS_,OBJ_NAME)(void *obj) \
{ return G_TYPE_CHECK_INSTANCE_TYPE(obj, module_obj_name ## _get_type()); } \
static inline SPICE_GNUC_UNUSED \
gboolean G_PASTE(G_PASTE(RED_IS_,OBJ_NAME),_CLASS)(void *klass) \
{ return G_TYPE_CHECK_CLASS_TYPE((klass), module_obj_name ## _get_type()); } \
static inline SPICE_GNUC_UNUSED \
ModuleObjName ## Class *G_PASTE(G_PASTE(RED_,OBJ_NAME),_GET_CLASS)(void *obj) \
{ return G_TYPE_INSTANCE_GET_CLASS(obj, \
module_obj_name ## _get_type(), ModuleObjName ## Class); }
/* This macro allows to use GLib for a class hieranrchy allocation.
* The aims are:
* - do not depend on C++ runtime, just C;
* - do not throw memory exception from a C library;
* - zero out the structure like GOject did, we are not still
* initializing automatically all members;
* - do not allow to allocate array of this type, do not mix fine
* with reference counting and inheritance.
*/
#define SPICE_CXX_GLIB_ALLOCATOR \
void *operator new(size_t size) { return g_malloc0(size); } \
void operator delete(void *p) { g_free(p); } \
void* operator new[](size_t count);
#ifdef __cplusplus
#include <glib-object.h>
inline GParamFlags operator|(GParamFlags a, GParamFlags b)
{
return (GParamFlags) ((int)a|(int)b);
}
#endif
// XXX todo remove, just for easy portability
#define XXX_CAST(from, to, name) \
static inline to* name(from *p) { \
return p ? static_cast<to*>(p) : nullptr; \
}
SPICE_END_DECLS
#endif /* RED_COMMON_H_ */
|
