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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
*
* Copyright (C) 2008 David Zeuthen <david@fubar.dk>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifndef __DEVKIT_DISKS_DEVICE_PRIVATE_H__
#define __DEVKIT_DISKS_DEVICE_PRIVATE_H__
#include <polkit-dbus/polkit-dbus.h>
#include <dbus/dbus-glib.h>
#include <devkit-gobject/devkit-gobject.h>
#include "devkit-disks-types.h"
G_BEGIN_DECLS
struct Job;
typedef struct Job Job;
#define SMART_DATA_STRUCT_TYPE (dbus_g_type_get_struct ("GValueArray", \
G_TYPE_INT, \
G_TYPE_STRING, \
G_TYPE_INT, \
G_TYPE_INT, \
G_TYPE_INT, \
G_TYPE_INT, \
G_TYPE_STRING, \
G_TYPE_INVALID))
#define HISTORICAL_SMART_DATA_STRUCT_TYPE (dbus_g_type_get_struct ("GValueArray", \
G_TYPE_UINT64, \
G_TYPE_DOUBLE, \
G_TYPE_UINT64, \
G_TYPE_STRING, \
G_TYPE_BOOLEAN, \
dbus_g_type_get_collection ("GPtrArray", SMART_DATA_STRUCT_TYPE), \
G_TYPE_INVALID))
#define LSOF_DATA_STRUCT_TYPE (dbus_g_type_get_struct ("GValueArray", \
G_TYPE_UINT, \
G_TYPE_UINT, \
G_TYPE_STRING, \
G_TYPE_INVALID))
struct DevkitDisksDevicePrivate
{
DBusGConnection *system_bus_connection;
DBusGProxy *system_bus_proxy;
DevkitDisksDaemon *daemon;
DevkitDevice *d;
Job *job;
char *object_path;
char *native_path;
gboolean removed;
gboolean job_in_progress;
char *job_id;
uid_t job_initiated_by_uid;
gboolean job_is_cancellable;
int job_num_tasks;
int job_cur_task;
char *job_cur_task_id;
double job_cur_task_percentage;
guint linux_md_poll_timeout_id;
/* A list of current polling inhibitors (DevkitDisksInhibitor objects) */
GList *polling_inhibitors;
/* if non-zero, the id of the idle for emitting a 'change' signal */
guint emit_changed_idle_id;
/**************/
/* properties */
/*************/
char *device_file;
GPtrArray *device_file_by_id;
GPtrArray *device_file_by_path;
gboolean device_is_system_internal;
gboolean device_is_partition;
gboolean device_is_partition_table;
gboolean device_is_removable;
gboolean device_is_media_available;
gboolean device_is_media_change_detected;
gboolean device_is_media_change_detection_inhibitable;
gboolean device_is_media_change_detection_inhibited;
gboolean device_is_read_only;
gboolean device_is_drive;
gboolean device_is_optical_disc;
gboolean device_is_luks;
gboolean device_is_luks_cleartext;
gboolean device_is_linux_md_component;
gboolean device_is_linux_md;
guint64 device_size;
guint64 device_block_size;
gboolean device_is_mounted;
char *device_mount_path;
uid_t device_mounted_by_uid;
char *device_presentation_name;
char *device_presentation_icon_name;
char *id_usage;
char *id_type;
char *id_version;
char *id_uuid;
char *id_label;
char *partition_slave;
char *partition_scheme;
char *partition_type;
char *partition_label;
char *partition_uuid;
GPtrArray *partition_flags;
int partition_number;
guint64 partition_offset;
guint64 partition_size;
char *partition_table_scheme;
int partition_table_count;
int partition_table_max_number;
GArray *partition_table_offsets;
GArray *partition_table_sizes;
char *drive_vendor;
char *drive_model;
char *drive_revision;
char *drive_serial;
char *drive_connection_interface;
guint drive_connection_speed;
GPtrArray *drive_media_compatibility;
char *drive_media;
gboolean drive_is_media_ejectable;
gboolean drive_requires_eject;
gboolean optical_disc_is_blank;
gboolean optical_disc_is_appendable;
gboolean optical_disc_is_closed;
guint optical_disc_num_tracks;
guint optical_disc_num_audio_tracks;
guint optical_disc_num_sessions;
char *luks_holder;
char *luks_cleartext_slave;
uid_t luks_cleartext_unlocked_by_uid;
char *linux_md_component_level;
int linux_md_component_num_raid_devices;
char *linux_md_component_uuid;
char *linux_md_component_home_host;
char *linux_md_component_name;
char *linux_md_component_version;
char *linux_md_component_holder;
GPtrArray *linux_md_component_state;
char *linux_md_state;
char *linux_md_level;
int linux_md_num_raid_devices;
char *linux_md_uuid;
char *linux_md_home_host;
char *linux_md_name;
char *linux_md_version;
GPtrArray *linux_md_slaves;
GPtrArray *linux_md_slaves_state;
gboolean linux_md_is_degraded;
char *linux_md_sync_action;
double linux_md_sync_percentage;
guint64 linux_md_sync_speed;
/* We want S.M.A.R.T. to persist over change events */
gboolean drive_smart_is_capable;
gboolean drive_smart_is_enabled;
guint64 drive_smart_time_collected;
gboolean drive_smart_is_failing;
double drive_smart_temperature;
guint64 drive_smart_time_powered_on;
char *drive_smart_last_self_test_result;
GPtrArray *drive_smart_attributes;
/* the following properties are not (yet) exported */
char *dm_name;
GPtrArray *slaves_objpath;
GPtrArray *holders_objpath;
};
/* property setters */
void devkit_disks_device_set_job_in_progress (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_job_id (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_job_initiated_by_uid (DevkitDisksDevice *device, guint value);
void devkit_disks_device_set_job_is_cancellable (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_job_num_tasks (DevkitDisksDevice *device, gint value);
void devkit_disks_device_set_job_cur_task (DevkitDisksDevice *device, gint value);
void devkit_disks_device_set_job_cur_task_id (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_job_cur_task_percentage (DevkitDisksDevice *device, gdouble value);
void devkit_disks_device_set_device_file (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_device_file_by_id (DevkitDisksDevice *device, GStrv value);
void devkit_disks_device_set_device_file_by_path (DevkitDisksDevice *device, GStrv value);
void devkit_disks_device_set_device_is_system_internal (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_partition (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_partition_table (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_removable (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_media_available (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_media_change_detected (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_media_change_detection_inhibitable (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_media_change_detection_inhibited (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_read_only (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_drive (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_optical_disc (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_luks (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_luks_cleartext (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_linux_md_component (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_is_linux_md (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_size (DevkitDisksDevice *device, guint64 value);
void devkit_disks_device_set_device_block_size (DevkitDisksDevice *device, guint64 value);
void devkit_disks_device_set_device_is_mounted (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_device_mount_path (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_device_mounted_by_uid (DevkitDisksDevice *device, guint value);
void devkit_disks_device_set_device_presentation_name (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_device_presentation_icon_name (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_id_usage (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_id_type (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_id_version (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_id_uuid (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_id_label (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_partition_slave (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_partition_scheme (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_partition_type (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_partition_label (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_partition_uuid (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_partition_flags (DevkitDisksDevice *device, GStrv value);
void devkit_disks_device_set_partition_number (DevkitDisksDevice *device, gint value);
void devkit_disks_device_set_partition_offset (DevkitDisksDevice *device, guint64 value);
void devkit_disks_device_set_partition_size (DevkitDisksDevice *device, guint64 value);
void devkit_disks_device_set_partition_table_scheme (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_partition_table_count (DevkitDisksDevice *device, gint value);
void devkit_disks_device_set_partition_table_max_number (DevkitDisksDevice *device, gint value);
void devkit_disks_device_set_partition_table_offsets (DevkitDisksDevice *device, GArray * value);
void devkit_disks_device_set_partition_table_sizes (DevkitDisksDevice *device, GArray * value);
void devkit_disks_device_set_drive_vendor (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_drive_model (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_drive_revision (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_drive_serial (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_drive_connection_interface (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_drive_connection_speed (DevkitDisksDevice *device, guint value);
void devkit_disks_device_set_drive_media_compatibility (DevkitDisksDevice *device, GStrv value);
void devkit_disks_device_set_drive_media (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_drive_is_media_ejectable (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_drive_requires_eject (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_optical_disc_is_blank (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_optical_disc_is_appendable (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_optical_disc_is_closed (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_optical_disc_num_tracks (DevkitDisksDevice *device, guint value);
void devkit_disks_device_set_optical_disc_num_audio_tracks (DevkitDisksDevice *device, guint value);
void devkit_disks_device_set_optical_disc_num_sessions (DevkitDisksDevice *device, guint value);
void devkit_disks_device_set_luks_holder (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_luks_cleartext_slave (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_luks_cleartext_unlocked_by_uid (DevkitDisksDevice *device, guint value);
void devkit_disks_device_set_linux_md_component_level (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_component_num_raid_devices (DevkitDisksDevice *device, gint value);
void devkit_disks_device_set_linux_md_component_uuid (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_component_home_host (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_component_name (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_component_version (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_component_holder (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_component_state (DevkitDisksDevice *device, GStrv value);
void devkit_disks_device_set_linux_md_state (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_level (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_num_raid_devices (DevkitDisksDevice *device, gint value);
void devkit_disks_device_set_linux_md_uuid (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_home_host (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_name (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_version (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_slaves (DevkitDisksDevice *device, GStrv value);
void devkit_disks_device_set_linux_md_is_degraded (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_linux_md_sync_action (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_linux_md_sync_percentage (DevkitDisksDevice *device, gdouble value);
void devkit_disks_device_set_linux_md_sync_speed (DevkitDisksDevice *device, guint64 value);
void devkit_disks_device_set_dm_name (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_slaves_objpath (DevkitDisksDevice *device, GStrv value);
void devkit_disks_device_set_holders_objpath (DevkitDisksDevice *device, GStrv value);
void devkit_disks_device_set_drive_smart_is_capable (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_drive_smart_is_enabled (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_drive_smart_time_collected (DevkitDisksDevice *device, guint64 value);
void devkit_disks_device_set_drive_smart_is_failing (DevkitDisksDevice *device, gboolean value);
void devkit_disks_device_set_drive_smart_temperature (DevkitDisksDevice *device, gdouble value);
void devkit_disks_device_set_drive_smart_time_powered_on (DevkitDisksDevice *device, guint64 value);
void devkit_disks_device_set_drive_smart_last_self_test_result (DevkitDisksDevice *device, const gchar *value);
void devkit_disks_device_set_drive_smart_attributes_steal (DevkitDisksDevice *device, GPtrArray *attributes);
G_END_DECLS
#endif /* __DEVKIT_DISKS_DEVICE_PRIVATE_H__ */
|