~ubuntu-branches/ubuntu/trusty/cgmanager/trusty-backports
» Revision
27
: org.linuxcontainers.cgmanager.c
« back to all changes in this revision
Viewing changes to org.linuxcontainers.cgmanager.c
- browse files at revision 27
- compare with another revision
- download diff
- download tarball
- view history from revision 27
- Committer: Package Import Robot
- Author(s): Stéphane Graber
- Date: 2015-10-15 12:32:18 UTC
- mfrom: (26.1.43 wily)
- Revision ID: package-import@ubuntu.com-20151015123218-tbjmj12qp7c3n7ve
Tags: 0.39-2ubuntu2~ubuntu14.04.1
No-change backport to trusty
- files added:
- .pc/0001-cgmanager-turn-cgroupfs-rw-before-trying-to-unlink-s.patch
- .pc/0002-move-cgm-release-agent-to-libexecdir.patch
- .pc/0003-make-sure-to-remove-cgm-release-agent-symlinks.patch
- .pc/0004-accomodate-systemd-s-init.scope-cgroup.patch
- config
- config/init
- config/init/systemd
- config/init/sysvinit
- config/init/upstart
- config/init/upstart/sessions
- pam
- files removed:
- .pc/0001-Add-sigstop-support.patch
- .pc/makefile-shared
- files modified:
- .pc/applied-patches
added
removed
org.linuxcontainers.cgmanager.c
33
33
34
34
35
35
/* Prototypes for static functions */
36
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Ping_method (NihDBusObject *object, NihDBusMessage *message);
37
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupScm_method (NihDBusObject *object, NihDBusMessage *message);
38
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroup_method (NihDBusObject *object, NihDBusMessage *message);
39
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_CreateScm_method (NihDBusObject *object, NihDBusMessage *message);
40
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Create_method (NihDBusObject *object, NihDBusMessage *message);
41
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ChownScm_method (NihDBusObject *object, NihDBusMessage *message);
42
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Chown_method (NihDBusObject *object, NihDBusMessage *message);
43
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ChmodScm_method (NihDBusObject *object, NihDBusMessage *message);
44
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Chmod_method (NihDBusObject *object, NihDBusMessage *message);
45
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_MovePidScm_method (NihDBusObject *object, NihDBusMessage *message);
46
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_MovePid_method (NihDBusObject *object, NihDBusMessage *message);
47
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbsScm_method (NihDBusObject *object, NihDBusMessage *message);
48
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbs_method (NihDBusObject *object, NihDBusMessage *message);
49
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetValueScm_method (NihDBusObject *object, NihDBusMessage *message);
50
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetValue_method (NihDBusObject *object, NihDBusMessage *message);
51
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_SetValueScm_method (NihDBusObject *object, NihDBusMessage *message);
52
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_SetValue_method (NihDBusObject *object, NihDBusMessage *message);
53
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_RemoveScm_method (NihDBusObject *object, NihDBusMessage *message);
54
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Remove_method (NihDBusObject *object, NihDBusMessage *message);
55
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksScm_method (NihDBusObject *object, NihDBusMessage *message);
56
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetTasks_method (NihDBusObject *object, NihDBusMessage *message);
57
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ListChildrenScm_method (NihDBusObject *object, NihDBusMessage *message);
58
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ListChildren_method (NihDBusObject *object, NihDBusMessage *message);
59
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmptyScm_method (NihDBusObject *object, NihDBusMessage *message);
60
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmpty_method (NihDBusObject *object, NihDBusMessage *message);
61
static int cgmanager_org_linuxcontainers_cgmanager0_0_api_version_get (NihDBusObject *object, NihDBusMessage *message, DBusMessageIter *iter);
36
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Ping_method (NihDBusObject *object, NihDBusMessage *message);
37
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupScm_method (NihDBusObject *object, NihDBusMessage *message);
38
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroup_method (NihDBusObject *object, NihDBusMessage *message);
39
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbsScm_method (NihDBusObject *object, NihDBusMessage *message);
40
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbs_method (NihDBusObject *object, NihDBusMessage *message);
41
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_CreateScm_method (NihDBusObject *object, NihDBusMessage *message);
42
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Create_method (NihDBusObject *object, NihDBusMessage *message);
43
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ChownScm_method (NihDBusObject *object, NihDBusMessage *message);
44
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Chown_method (NihDBusObject *object, NihDBusMessage *message);
45
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ChmodScm_method (NihDBusObject *object, NihDBusMessage *message);
46
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Chmod_method (NihDBusObject *object, NihDBusMessage *message);
47
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_MovePidScm_method (NihDBusObject *object, NihDBusMessage *message);
48
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_MovePid_method (NihDBusObject *object, NihDBusMessage *message);
49
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbsScm_method (NihDBusObject *object, NihDBusMessage *message);
50
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbs_method (NihDBusObject *object, NihDBusMessage *message);
51
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetValueScm_method (NihDBusObject *object, NihDBusMessage *message);
52
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetValue_method (NihDBusObject *object, NihDBusMessage *message);
53
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_SetValueScm_method (NihDBusObject *object, NihDBusMessage *message);
54
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_SetValue_method (NihDBusObject *object, NihDBusMessage *message);
55
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_RemoveScm_method (NihDBusObject *object, NihDBusMessage *message);
56
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Remove_method (NihDBusObject *object, NihDBusMessage *message);
57
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksScm_method (NihDBusObject *object, NihDBusMessage *message);
58
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetTasks_method (NihDBusObject *object, NihDBusMessage *message);
59
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursiveScm_method (NihDBusObject *object, NihDBusMessage *message);
60
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursive_method (NihDBusObject *object, NihDBusMessage *message);
61
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ListChildrenScm_method (NihDBusObject *object, NihDBusMessage *message);
62
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ListChildren_method (NihDBusObject *object, NihDBusMessage *message);
63
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmptyScm_method (NihDBusObject *object, NihDBusMessage *message);
64
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmpty_method (NihDBusObject *object, NihDBusMessage *message);
65
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_PruneScm_method (NihDBusObject *object, NihDBusMessage *message);
66
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_Prune_method (NihDBusObject *object, NihDBusMessage *message);
67
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ListControllers_method (NihDBusObject *object, NihDBusMessage *message);
68
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ListKeysScm_method (NihDBusObject *object, NihDBusMessage *message);
69
static DBusHandlerResult cgmanager_org_linuxcontainers_cgmanager0_0_ListKeys_method (NihDBusObject *object, NihDBusMessage *message);
70
static int cgmanager_org_linuxcontainers_cgmanager0_0_api_version_get (NihDBusObject *object, NihDBusMessage *message, DBusMessageIter *iter);
62
71
63
72
64
73
/* Prototypes for externally implemented handler functions */
65
extern int cgmanager_ping (void *data, NihDBusMessage *message, int32_t junk)
66
__attribute__ ((warn_unused_result));
67
extern int cgmanager_get_pid_cgroup_scm (void *data, NihDBusMessage *message, const char *controller, int sockfd)
68
__attribute__ ((warn_unused_result));
69
extern int cgmanager_get_pid_cgroup (void *data, NihDBusMessage *message, const char *controller, int32_t pid, char **output)
70
__attribute__ ((warn_unused_result));
71
extern int cgmanager_create_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
72
__attribute__ ((warn_unused_result));
73
extern int cgmanager_create (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t *existed)
74
__attribute__ ((warn_unused_result));
75
extern int cgmanager_chown_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
76
__attribute__ ((warn_unused_result));
77
extern int cgmanager_chown (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t uid, int32_t gid)
78
__attribute__ ((warn_unused_result));
79
extern int cgmanager_chmod_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *file, int32_t mode, int sockfd)
80
__attribute__ ((warn_unused_result));
81
extern int cgmanager_chmod (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *file, int32_t mode)
82
__attribute__ ((warn_unused_result));
83
extern int cgmanager_move_pid_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
84
__attribute__ ((warn_unused_result));
85
extern int cgmanager_move_pid (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t pid)
86
__attribute__ ((warn_unused_result));
87
extern int cgmanager_move_pid_abs_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
88
__attribute__ ((warn_unused_result));
89
extern int cgmanager_move_pid_abs (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t pid)
90
__attribute__ ((warn_unused_result));
91
extern int cgmanager_get_value_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *key, int sockfd)
92
__attribute__ ((warn_unused_result));
93
extern int cgmanager_get_value (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *key, char **value)
94
__attribute__ ((warn_unused_result));
95
extern int cgmanager_set_value_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *key, const char *value, int sockfd)
96
__attribute__ ((warn_unused_result));
97
extern int cgmanager_set_value (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *key, const char *value)
98
__attribute__ ((warn_unused_result));
99
extern int cgmanager_remove_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t recursive, int sockfd)
100
__attribute__ ((warn_unused_result));
101
extern int cgmanager_remove (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t recursive, int32_t *existed)
102
__attribute__ ((warn_unused_result));
103
extern int cgmanager_get_tasks_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
104
__attribute__ ((warn_unused_result));
105
extern int cgmanager_get_tasks (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t **output, size_t *output_len)
106
__attribute__ ((warn_unused_result));
107
extern int cgmanager_list_children_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
108
__attribute__ ((warn_unused_result));
109
extern int cgmanager_list_children (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, char ***output)
110
__attribute__ ((warn_unused_result));
111
extern int cgmanager_remove_on_empty_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
112
__attribute__ ((warn_unused_result));
113
extern int cgmanager_remove_on_empty (void *data, NihDBusMessage *message, const char *controller, const char *cgroup)
114
__attribute__ ((warn_unused_result));
115
extern int cgmanager_get_api_version (void *data, NihDBusMessage *message, int32_t *value)
74
extern int cgmanager_ping (void *data, NihDBusMessage *message, int32_t junk)
75
__attribute__ ((warn_unused_result));
76
extern int cgmanager_get_pid_cgroup_scm (void *data, NihDBusMessage *message, const char *controller, int sockfd)
77
__attribute__ ((warn_unused_result));
78
extern int cgmanager_get_pid_cgroup (void *data, NihDBusMessage *message, const char *controller, int32_t pid, char **output)
79
__attribute__ ((warn_unused_result));
80
extern int cgmanager_get_pid_cgroup_abs_scm (void *data, NihDBusMessage *message, const char *controller, int sockfd)
81
__attribute__ ((warn_unused_result));
82
extern int cgmanager_get_pid_cgroup_abs (void *data, NihDBusMessage *message, const char *controller, int32_t pid, char **output)
83
__attribute__ ((warn_unused_result));
84
extern int cgmanager_create_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
85
__attribute__ ((warn_unused_result));
86
extern int cgmanager_create (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t *existed)
87
__attribute__ ((warn_unused_result));
88
extern int cgmanager_chown_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
89
__attribute__ ((warn_unused_result));
90
extern int cgmanager_chown (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t uid, int32_t gid)
91
__attribute__ ((warn_unused_result));
92
extern int cgmanager_chmod_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *file, int32_t mode, int sockfd)
93
__attribute__ ((warn_unused_result));
94
extern int cgmanager_chmod (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *file, int32_t mode)
95
__attribute__ ((warn_unused_result));
96
extern int cgmanager_move_pid_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
97
__attribute__ ((warn_unused_result));
98
extern int cgmanager_move_pid (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t pid)
99
__attribute__ ((warn_unused_result));
100
extern int cgmanager_move_pid_abs_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
101
__attribute__ ((warn_unused_result));
102
extern int cgmanager_move_pid_abs (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t pid)
103
__attribute__ ((warn_unused_result));
104
extern int cgmanager_get_value_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *key, int sockfd)
105
__attribute__ ((warn_unused_result));
106
extern int cgmanager_get_value (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *key, char **value)
107
__attribute__ ((warn_unused_result));
108
extern int cgmanager_set_value_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *key, const char *value, int sockfd)
109
__attribute__ ((warn_unused_result));
110
extern int cgmanager_set_value (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, const char *key, const char *value)
111
__attribute__ ((warn_unused_result));
112
extern int cgmanager_remove_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t recursive, int sockfd)
113
__attribute__ ((warn_unused_result));
114
extern int cgmanager_remove (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t recursive, int32_t *existed)
115
__attribute__ ((warn_unused_result));
116
extern int cgmanager_get_tasks_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
117
__attribute__ ((warn_unused_result));
118
extern int cgmanager_get_tasks (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t **output, size_t *output_len)
119
__attribute__ ((warn_unused_result));
120
extern int cgmanager_get_tasks_recursive_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
121
__attribute__ ((warn_unused_result));
122
extern int cgmanager_get_tasks_recursive (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int32_t **output, size_t *output_len)
123
__attribute__ ((warn_unused_result));
124
extern int cgmanager_list_children_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
125
__attribute__ ((warn_unused_result));
126
extern int cgmanager_list_children (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, char ***output)
127
__attribute__ ((warn_unused_result));
128
extern int cgmanager_remove_on_empty_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
129
__attribute__ ((warn_unused_result));
130
extern int cgmanager_remove_on_empty (void *data, NihDBusMessage *message, const char *controller, const char *cgroup)
131
__attribute__ ((warn_unused_result));
132
extern int cgmanager_prune_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
133
__attribute__ ((warn_unused_result));
134
extern int cgmanager_prune (void *data, NihDBusMessage *message, const char *controller, const char *cgroup)
135
__attribute__ ((warn_unused_result));
136
extern int cgmanager_list_controllers (void *data, NihDBusMessage *message, char ***output)
137
__attribute__ ((warn_unused_result));
138
extern int cgmanager_list_keys_scm (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, int sockfd)
139
__attribute__ ((warn_unused_result));
140
extern int cgmanager_list_keys (void *data, NihDBusMessage *message, const char *controller, const char *cgroup, CgmanagerListKeysOutputElement ***output)
141
__attribute__ ((warn_unused_result));
142
extern int cgmanager_get_api_version (void *data, NihDBusMessage *message, int32_t *value)
116
143
__attribute__ ((warn_unused_result));
117
144
118
145
134
161
{ NULL }
135
162
};
136
163
164
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbsScm_method_args[] = {
165
{ "controller", "s", NIH_DBUS_ARG_IN },
166
{ "sockfd", "h", NIH_DBUS_ARG_IN },
167
{ NULL }
168
};
169
170
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbs_method_args[] = {
171
{ "controller", "s", NIH_DBUS_ARG_IN },
172
{ "pid", "i", NIH_DBUS_ARG_IN },
173
{ "output", "s", NIH_DBUS_ARG_OUT },
174
{ NULL }
175
};
176
137
177
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_CreateScm_method_args[] = {
138
178
{ "controller", "s", NIH_DBUS_ARG_IN },
139
179
{ "cgroup", "s", NIH_DBUS_ARG_IN },
271
311
{ NULL }
272
312
};
273
313
314
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursiveScm_method_args[] = {
315
{ "controller", "s", NIH_DBUS_ARG_IN },
316
{ "cgroup", "s", NIH_DBUS_ARG_IN },
317
{ "sockfd", "h", NIH_DBUS_ARG_IN },
318
{ NULL }
319
};
320
321
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursive_method_args[] = {
322
{ "controller", "s", NIH_DBUS_ARG_IN },
323
{ "cgroup", "s", NIH_DBUS_ARG_IN },
324
{ "output", "ai", NIH_DBUS_ARG_OUT },
325
{ NULL }
326
};
327
274
328
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_ListChildrenScm_method_args[] = {
275
329
{ "controller", "s", NIH_DBUS_ARG_IN },
276
330
{ "cgroup", "s", NIH_DBUS_ARG_IN },
298
352
{ NULL }
299
353
};
300
354
355
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_PruneScm_method_args[] = {
356
{ "controller", "s", NIH_DBUS_ARG_IN },
357
{ "cgroup", "s", NIH_DBUS_ARG_IN },
358
{ "sockfd", "h", NIH_DBUS_ARG_IN },
359
{ NULL }
360
};
361
362
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_Prune_method_args[] = {
363
{ "controller", "s", NIH_DBUS_ARG_IN },
364
{ "cgroup", "s", NIH_DBUS_ARG_IN },
365
{ NULL }
366
};
367
368
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_ListControllers_method_args[] = {
369
{ "output", "as", NIH_DBUS_ARG_OUT },
370
{ NULL }
371
};
372
373
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_ListKeysScm_method_args[] = {
374
{ "controller", "s", NIH_DBUS_ARG_IN },
375
{ "cgroup", "s", NIH_DBUS_ARG_IN },
376
{ "sockfd", "h", NIH_DBUS_ARG_IN },
377
{ NULL }
378
};
379
380
static const NihDBusArg cgmanager_org_linuxcontainers_cgmanager0_0_ListKeys_method_args[] = {
381
{ "controller", "s", NIH_DBUS_ARG_IN },
382
{ "cgroup", "s", NIH_DBUS_ARG_IN },
383
{ "output", "a(suuu)", NIH_DBUS_ARG_OUT },
384
{ NULL }
385
};
386
301
387
static const NihDBusMethod cgmanager_org_linuxcontainers_cgmanager0_0_methods[] = {
302
{ "Ping", cgmanager_org_linuxcontainers_cgmanager0_0_Ping_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Ping_method },
303
{ "GetPidCgroupScm", cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupScm_method },
304
{ "GetPidCgroup", cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroup_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroup_method },
305
{ "CreateScm", cgmanager_org_linuxcontainers_cgmanager0_0_CreateScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_CreateScm_method },
306
{ "Create", cgmanager_org_linuxcontainers_cgmanager0_0_Create_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Create_method },
307
{ "ChownScm", cgmanager_org_linuxcontainers_cgmanager0_0_ChownScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ChownScm_method },
308
{ "Chown", cgmanager_org_linuxcontainers_cgmanager0_0_Chown_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Chown_method },
309
{ "ChmodScm", cgmanager_org_linuxcontainers_cgmanager0_0_ChmodScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ChmodScm_method },
310
{ "Chmod", cgmanager_org_linuxcontainers_cgmanager0_0_Chmod_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Chmod_method },
311
{ "MovePidScm", cgmanager_org_linuxcontainers_cgmanager0_0_MovePidScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_MovePidScm_method },
312
{ "MovePid", cgmanager_org_linuxcontainers_cgmanager0_0_MovePid_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_MovePid_method },
313
{ "MovePidAbsScm", cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbsScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbsScm_method },
314
{ "MovePidAbs", cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbs_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbs_method },
315
{ "GetValueScm", cgmanager_org_linuxcontainers_cgmanager0_0_GetValueScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetValueScm_method },
316
{ "GetValue", cgmanager_org_linuxcontainers_cgmanager0_0_GetValue_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetValue_method },
317
{ "SetValueScm", cgmanager_org_linuxcontainers_cgmanager0_0_SetValueScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_SetValueScm_method },
318
{ "SetValue", cgmanager_org_linuxcontainers_cgmanager0_0_SetValue_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_SetValue_method },
319
{ "RemoveScm", cgmanager_org_linuxcontainers_cgmanager0_0_RemoveScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_RemoveScm_method },
320
{ "Remove", cgmanager_org_linuxcontainers_cgmanager0_0_Remove_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Remove_method },
321
{ "GetTasksScm", cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksScm_method },
322
{ "GetTasks", cgmanager_org_linuxcontainers_cgmanager0_0_GetTasks_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetTasks_method },
323
{ "ListChildrenScm", cgmanager_org_linuxcontainers_cgmanager0_0_ListChildrenScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ListChildrenScm_method },
324
{ "ListChildren", cgmanager_org_linuxcontainers_cgmanager0_0_ListChildren_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ListChildren_method },
325
{ "RemoveOnEmptyScm", cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmptyScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmptyScm_method },
326
{ "RemoveOnEmpty", cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmpty_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmpty_method },
388
{ "Ping", cgmanager_org_linuxcontainers_cgmanager0_0_Ping_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Ping_method },
389
{ "GetPidCgroupScm", cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupScm_method },
390
{ "GetPidCgroup", cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroup_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroup_method },
391
{ "GetPidCgroupAbsScm", cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbsScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbsScm_method },
392
{ "GetPidCgroupAbs", cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbs_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbs_method },
393
{ "CreateScm", cgmanager_org_linuxcontainers_cgmanager0_0_CreateScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_CreateScm_method },
394
{ "Create", cgmanager_org_linuxcontainers_cgmanager0_0_Create_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Create_method },
395
{ "ChownScm", cgmanager_org_linuxcontainers_cgmanager0_0_ChownScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ChownScm_method },
396
{ "Chown", cgmanager_org_linuxcontainers_cgmanager0_0_Chown_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Chown_method },
397
{ "ChmodScm", cgmanager_org_linuxcontainers_cgmanager0_0_ChmodScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ChmodScm_method },
398
{ "Chmod", cgmanager_org_linuxcontainers_cgmanager0_0_Chmod_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Chmod_method },
399
{ "MovePidScm", cgmanager_org_linuxcontainers_cgmanager0_0_MovePidScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_MovePidScm_method },
400
{ "MovePid", cgmanager_org_linuxcontainers_cgmanager0_0_MovePid_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_MovePid_method },
401
{ "MovePidAbsScm", cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbsScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbsScm_method },
402
{ "MovePidAbs", cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbs_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_MovePidAbs_method },
403
{ "GetValueScm", cgmanager_org_linuxcontainers_cgmanager0_0_GetValueScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetValueScm_method },
404
{ "GetValue", cgmanager_org_linuxcontainers_cgmanager0_0_GetValue_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetValue_method },
405
{ "SetValueScm", cgmanager_org_linuxcontainers_cgmanager0_0_SetValueScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_SetValueScm_method },
406
{ "SetValue", cgmanager_org_linuxcontainers_cgmanager0_0_SetValue_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_SetValue_method },
407
{ "RemoveScm", cgmanager_org_linuxcontainers_cgmanager0_0_RemoveScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_RemoveScm_method },
408
{ "Remove", cgmanager_org_linuxcontainers_cgmanager0_0_Remove_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Remove_method },
409
{ "GetTasksScm", cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksScm_method },
410
{ "GetTasks", cgmanager_org_linuxcontainers_cgmanager0_0_GetTasks_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetTasks_method },
411
{ "GetTasksRecursiveScm", cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursiveScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursiveScm_method },
412
{ "GetTasksRecursive", cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursive_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursive_method },
413
{ "ListChildrenScm", cgmanager_org_linuxcontainers_cgmanager0_0_ListChildrenScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ListChildrenScm_method },
414
{ "ListChildren", cgmanager_org_linuxcontainers_cgmanager0_0_ListChildren_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ListChildren_method },
415
{ "RemoveOnEmptyScm", cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmptyScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmptyScm_method },
416
{ "RemoveOnEmpty", cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmpty_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_RemoveOnEmpty_method },
417
{ "PruneScm", cgmanager_org_linuxcontainers_cgmanager0_0_PruneScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_PruneScm_method },
418
{ "Prune", cgmanager_org_linuxcontainers_cgmanager0_0_Prune_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_Prune_method },
419
{ "ListControllers", cgmanager_org_linuxcontainers_cgmanager0_0_ListControllers_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ListControllers_method },
420
{ "ListKeysScm", cgmanager_org_linuxcontainers_cgmanager0_0_ListKeysScm_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ListKeysScm_method },
421
{ "ListKeys", cgmanager_org_linuxcontainers_cgmanager0_0_ListKeys_method_args, cgmanager_org_linuxcontainers_cgmanager0_0_ListKeys_method },
327
422
{ NULL }
328
423
};
329
424
751
846
752
847
753
848
static DBusHandlerResult
849
cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbsScm_method (NihDBusObject * object,
850
NihDBusMessage *message)
851
{
852
DBusMessageIter iter;
853
DBusMessage * reply;
854
char * controller;
855
const char * controller_dbus;
856
int sockfd;
857
858
nih_assert (object != NULL);
859
nih_assert (message != NULL);
860
861
/* Iterate the arguments to the message and demarshal into arguments
862
* for our own function call.
863
*/
864
dbus_message_iter_init (message->message, &iter);
865
866
/* Demarshal a char * from the message */
867
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
868
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
869
"Invalid arguments to GetPidCgroupAbsScm method");
870
if (! reply)
871
return DBUS_HANDLER_RESULT_NEED_MEMORY;
872
873
if (! dbus_connection_send (message->connection, reply, NULL)) {
874
dbus_message_unref (reply);
875
return DBUS_HANDLER_RESULT_NEED_MEMORY;
876
}
877
878
dbus_message_unref (reply);
879
return DBUS_HANDLER_RESULT_HANDLED;
880
}
881
882
dbus_message_iter_get_basic (&iter, &controller_dbus);
883
884
controller = nih_strdup (message, controller_dbus);
885
if (! controller) {
886
return DBUS_HANDLER_RESULT_NEED_MEMORY;
887
}
888
889
dbus_message_iter_next (&iter);
890
891
/* Demarshal a int from the message */
892
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_UNIX_FD) {
893
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
894
"Invalid arguments to GetPidCgroupAbsScm method");
895
if (! reply)
896
return DBUS_HANDLER_RESULT_NEED_MEMORY;
897
898
if (! dbus_connection_send (message->connection, reply, NULL)) {
899
dbus_message_unref (reply);
900
return DBUS_HANDLER_RESULT_NEED_MEMORY;
901
}
902
903
dbus_message_unref (reply);
904
return DBUS_HANDLER_RESULT_HANDLED;
905
}
906
907
dbus_message_iter_get_basic (&iter, &sockfd);
908
909
dbus_message_iter_next (&iter);
910
911
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
912
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
913
"Invalid arguments to GetPidCgroupAbsScm method");
914
if (! reply)
915
return DBUS_HANDLER_RESULT_NEED_MEMORY;
916
917
if (! dbus_connection_send (message->connection, reply, NULL)) {
918
dbus_message_unref (reply);
919
return DBUS_HANDLER_RESULT_NEED_MEMORY;
920
}
921
922
dbus_message_unref (reply);
923
return DBUS_HANDLER_RESULT_HANDLED;
924
}
925
926
/* Call the handler function */
927
nih_error_push_context ();
928
if (cgmanager_get_pid_cgroup_abs_scm (object->data, message, controller, sockfd) < 0) {
929
NihError *err;
930
931
err = nih_error_get ();
932
if (err->number == ENOMEM) {
933
nih_free (err);
934
nih_error_pop_context ();
935
936
return DBUS_HANDLER_RESULT_NEED_MEMORY;
937
} else if (err->number == NIH_DBUS_ERROR) {
938
NihDBusError *dbus_err = (NihDBusError *)err;
939
940
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
941
nih_free (err);
942
nih_error_pop_context ();
943
944
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
945
946
dbus_message_unref (reply);
947
return DBUS_HANDLER_RESULT_HANDLED;
948
} else {
949
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
950
nih_free (err);
951
nih_error_pop_context ();
952
953
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
954
955
dbus_message_unref (reply);
956
return DBUS_HANDLER_RESULT_HANDLED;
957
}
958
}
959
nih_error_pop_context ();
960
961
/* If the sender doesn't care about a reply, don't bother wasting
962
* effort constructing and sending one.
963
*/
964
if (dbus_message_get_no_reply (message->message))
965
return DBUS_HANDLER_RESULT_HANDLED;
966
967
do {
968
__label__ enomem;
969
970
/* Construct the reply message. */
971
reply = dbus_message_new_method_return (message->message);
972
if (! reply)
973
goto enomem;
974
975
dbus_message_iter_init_append (reply, &iter);
976
enomem: __attribute__ ((unused));
977
} while (! reply);
978
979
/* Send the reply, appending it to the outgoing queue. */
980
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
981
982
dbus_message_unref (reply);
983
984
return DBUS_HANDLER_RESULT_HANDLED;
985
}
986
987
988
static DBusHandlerResult
989
cgmanager_org_linuxcontainers_cgmanager0_0_GetPidCgroupAbs_method (NihDBusObject * object,
990
NihDBusMessage *message)
991
{
992
DBusMessageIter iter;
993
DBusMessage * reply;
994
char * controller;
995
const char * controller_dbus;
996
int32_t pid;
997
char * output;
998
999
nih_assert (object != NULL);
1000
nih_assert (message != NULL);
1001
1002
/* Iterate the arguments to the message and demarshal into arguments
1003
* for our own function call.
1004
*/
1005
dbus_message_iter_init (message->message, &iter);
1006
1007
/* Demarshal a char * from the message */
1008
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
1009
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
1010
"Invalid arguments to GetPidCgroupAbs method");
1011
if (! reply)
1012
return DBUS_HANDLER_RESULT_NEED_MEMORY;
1013
1014
if (! dbus_connection_send (message->connection, reply, NULL)) {
1015
dbus_message_unref (reply);
1016
return DBUS_HANDLER_RESULT_NEED_MEMORY;
1017
}
1018
1019
dbus_message_unref (reply);
1020
return DBUS_HANDLER_RESULT_HANDLED;
1021
}
1022
1023
dbus_message_iter_get_basic (&iter, &controller_dbus);
1024
1025
controller = nih_strdup (message, controller_dbus);
1026
if (! controller) {
1027
return DBUS_HANDLER_RESULT_NEED_MEMORY;
1028
}
1029
1030
dbus_message_iter_next (&iter);
1031
1032
/* Demarshal a int32_t from the message */
1033
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INT32) {
1034
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
1035
"Invalid arguments to GetPidCgroupAbs method");
1036
if (! reply)
1037
return DBUS_HANDLER_RESULT_NEED_MEMORY;
1038
1039
if (! dbus_connection_send (message->connection, reply, NULL)) {
1040
dbus_message_unref (reply);
1041
return DBUS_HANDLER_RESULT_NEED_MEMORY;
1042
}
1043
1044
dbus_message_unref (reply);
1045
return DBUS_HANDLER_RESULT_HANDLED;
1046
}
1047
1048
dbus_message_iter_get_basic (&iter, &pid);
1049
1050
dbus_message_iter_next (&iter);
1051
1052
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
1053
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
1054
"Invalid arguments to GetPidCgroupAbs method");
1055
if (! reply)
1056
return DBUS_HANDLER_RESULT_NEED_MEMORY;
1057
1058
if (! dbus_connection_send (message->connection, reply, NULL)) {
1059
dbus_message_unref (reply);
1060
return DBUS_HANDLER_RESULT_NEED_MEMORY;
1061
}
1062
1063
dbus_message_unref (reply);
1064
return DBUS_HANDLER_RESULT_HANDLED;
1065
}
1066
1067
/* Call the handler function */
1068
nih_error_push_context ();
1069
if (cgmanager_get_pid_cgroup_abs (object->data, message, controller, pid, &output) < 0) {
1070
NihError *err;
1071
1072
err = nih_error_get ();
1073
if (err->number == ENOMEM) {
1074
nih_free (err);
1075
nih_error_pop_context ();
1076
1077
return DBUS_HANDLER_RESULT_NEED_MEMORY;
1078
} else if (err->number == NIH_DBUS_ERROR) {
1079
NihDBusError *dbus_err = (NihDBusError *)err;
1080
1081
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
1082
nih_free (err);
1083
nih_error_pop_context ();
1084
1085
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
1086
1087
dbus_message_unref (reply);
1088
return DBUS_HANDLER_RESULT_HANDLED;
1089
} else {
1090
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
1091
nih_free (err);
1092
nih_error_pop_context ();
1093
1094
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
1095
1096
dbus_message_unref (reply);
1097
return DBUS_HANDLER_RESULT_HANDLED;
1098
}
1099
}
1100
nih_error_pop_context ();
1101
1102
/* If the sender doesn't care about a reply, don't bother wasting
1103
* effort constructing and sending one.
1104
*/
1105
if (dbus_message_get_no_reply (message->message))
1106
return DBUS_HANDLER_RESULT_HANDLED;
1107
1108
do {
1109
__label__ enomem;
1110
1111
/* Construct the reply message. */
1112
reply = dbus_message_new_method_return (message->message);
1113
if (! reply)
1114
goto enomem;
1115
1116
dbus_message_iter_init_append (reply, &iter);
1117
1118
/* Marshal a char * onto the message */
1119
if (! dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &output)) {
1120
dbus_message_unref (reply);
1121
reply = NULL;
1122
goto enomem;
1123
}
1124
enomem: __attribute__ ((unused));
1125
} while (! reply);
1126
1127
/* Send the reply, appending it to the outgoing queue. */
1128
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
1129
1130
dbus_message_unref (reply);
1131
1132
return DBUS_HANDLER_RESULT_HANDLED;
1133
}
1134
1135
1136
static DBusHandlerResult
754
1137
cgmanager_org_linuxcontainers_cgmanager0_0_CreateScm_method (NihDBusObject * object,
755
1138
NihDBusMessage *message)
756
1139
{
4006
4389
4007
4390
4008
4391
static DBusHandlerResult
4392
cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursiveScm_method (NihDBusObject * object,
4393
NihDBusMessage *message)
4394
{
4395
DBusMessageIter iter;
4396
DBusMessage * reply;
4397
char * controller;
4398
const char * controller_dbus;
4399
char * cgroup;
4400
const char * cgroup_dbus;
4401
int sockfd;
4402
4403
nih_assert (object != NULL);
4404
nih_assert (message != NULL);
4405
4406
/* Iterate the arguments to the message and demarshal into arguments
4407
* for our own function call.
4408
*/
4409
dbus_message_iter_init (message->message, &iter);
4410
4411
/* Demarshal a char * from the message */
4412
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
4413
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
4414
"Invalid arguments to GetTasksRecursiveScm method");
4415
if (! reply)
4416
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4417
4418
if (! dbus_connection_send (message->connection, reply, NULL)) {
4419
dbus_message_unref (reply);
4420
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4421
}
4422
4423
dbus_message_unref (reply);
4424
return DBUS_HANDLER_RESULT_HANDLED;
4425
}
4426
4427
dbus_message_iter_get_basic (&iter, &controller_dbus);
4428
4429
controller = nih_strdup (message, controller_dbus);
4430
if (! controller) {
4431
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4432
}
4433
4434
dbus_message_iter_next (&iter);
4435
4436
/* Demarshal a char * from the message */
4437
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
4438
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
4439
"Invalid arguments to GetTasksRecursiveScm method");
4440
if (! reply)
4441
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4442
4443
if (! dbus_connection_send (message->connection, reply, NULL)) {
4444
dbus_message_unref (reply);
4445
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4446
}
4447
4448
dbus_message_unref (reply);
4449
return DBUS_HANDLER_RESULT_HANDLED;
4450
}
4451
4452
dbus_message_iter_get_basic (&iter, &cgroup_dbus);
4453
4454
cgroup = nih_strdup (message, cgroup_dbus);
4455
if (! cgroup) {
4456
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4457
}
4458
4459
dbus_message_iter_next (&iter);
4460
4461
/* Demarshal a int from the message */
4462
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_UNIX_FD) {
4463
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
4464
"Invalid arguments to GetTasksRecursiveScm method");
4465
if (! reply)
4466
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4467
4468
if (! dbus_connection_send (message->connection, reply, NULL)) {
4469
dbus_message_unref (reply);
4470
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4471
}
4472
4473
dbus_message_unref (reply);
4474
return DBUS_HANDLER_RESULT_HANDLED;
4475
}
4476
4477
dbus_message_iter_get_basic (&iter, &sockfd);
4478
4479
dbus_message_iter_next (&iter);
4480
4481
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
4482
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
4483
"Invalid arguments to GetTasksRecursiveScm method");
4484
if (! reply)
4485
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4486
4487
if (! dbus_connection_send (message->connection, reply, NULL)) {
4488
dbus_message_unref (reply);
4489
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4490
}
4491
4492
dbus_message_unref (reply);
4493
return DBUS_HANDLER_RESULT_HANDLED;
4494
}
4495
4496
/* Call the handler function */
4497
nih_error_push_context ();
4498
if (cgmanager_get_tasks_recursive_scm (object->data, message, controller, cgroup, sockfd) < 0) {
4499
NihError *err;
4500
4501
err = nih_error_get ();
4502
if (err->number == ENOMEM) {
4503
nih_free (err);
4504
nih_error_pop_context ();
4505
4506
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4507
} else if (err->number == NIH_DBUS_ERROR) {
4508
NihDBusError *dbus_err = (NihDBusError *)err;
4509
4510
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
4511
nih_free (err);
4512
nih_error_pop_context ();
4513
4514
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
4515
4516
dbus_message_unref (reply);
4517
return DBUS_HANDLER_RESULT_HANDLED;
4518
} else {
4519
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
4520
nih_free (err);
4521
nih_error_pop_context ();
4522
4523
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
4524
4525
dbus_message_unref (reply);
4526
return DBUS_HANDLER_RESULT_HANDLED;
4527
}
4528
}
4529
nih_error_pop_context ();
4530
4531
/* If the sender doesn't care about a reply, don't bother wasting
4532
* effort constructing and sending one.
4533
*/
4534
if (dbus_message_get_no_reply (message->message))
4535
return DBUS_HANDLER_RESULT_HANDLED;
4536
4537
do {
4538
__label__ enomem;
4539
4540
/* Construct the reply message. */
4541
reply = dbus_message_new_method_return (message->message);
4542
if (! reply)
4543
goto enomem;
4544
4545
dbus_message_iter_init_append (reply, &iter);
4546
enomem: __attribute__ ((unused));
4547
} while (! reply);
4548
4549
/* Send the reply, appending it to the outgoing queue. */
4550
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
4551
4552
dbus_message_unref (reply);
4553
4554
return DBUS_HANDLER_RESULT_HANDLED;
4555
}
4556
4557
4558
static DBusHandlerResult
4559
cgmanager_org_linuxcontainers_cgmanager0_0_GetTasksRecursive_method (NihDBusObject * object,
4560
NihDBusMessage *message)
4561
{
4562
DBusMessageIter iter;
4563
DBusMessage * reply;
4564
char * controller;
4565
const char * controller_dbus;
4566
char * cgroup;
4567
const char * cgroup_dbus;
4568
int32_t * output;
4569
size_t output_len;
4570
DBusMessageIter output_iter;
4571
4572
nih_assert (object != NULL);
4573
nih_assert (message != NULL);
4574
4575
/* Iterate the arguments to the message and demarshal into arguments
4576
* for our own function call.
4577
*/
4578
dbus_message_iter_init (message->message, &iter);
4579
4580
/* Demarshal a char * from the message */
4581
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
4582
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
4583
"Invalid arguments to GetTasksRecursive method");
4584
if (! reply)
4585
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4586
4587
if (! dbus_connection_send (message->connection, reply, NULL)) {
4588
dbus_message_unref (reply);
4589
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4590
}
4591
4592
dbus_message_unref (reply);
4593
return DBUS_HANDLER_RESULT_HANDLED;
4594
}
4595
4596
dbus_message_iter_get_basic (&iter, &controller_dbus);
4597
4598
controller = nih_strdup (message, controller_dbus);
4599
if (! controller) {
4600
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4601
}
4602
4603
dbus_message_iter_next (&iter);
4604
4605
/* Demarshal a char * from the message */
4606
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
4607
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
4608
"Invalid arguments to GetTasksRecursive method");
4609
if (! reply)
4610
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4611
4612
if (! dbus_connection_send (message->connection, reply, NULL)) {
4613
dbus_message_unref (reply);
4614
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4615
}
4616
4617
dbus_message_unref (reply);
4618
return DBUS_HANDLER_RESULT_HANDLED;
4619
}
4620
4621
dbus_message_iter_get_basic (&iter, &cgroup_dbus);
4622
4623
cgroup = nih_strdup (message, cgroup_dbus);
4624
if (! cgroup) {
4625
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4626
}
4627
4628
dbus_message_iter_next (&iter);
4629
4630
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
4631
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
4632
"Invalid arguments to GetTasksRecursive method");
4633
if (! reply)
4634
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4635
4636
if (! dbus_connection_send (message->connection, reply, NULL)) {
4637
dbus_message_unref (reply);
4638
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4639
}
4640
4641
dbus_message_unref (reply);
4642
return DBUS_HANDLER_RESULT_HANDLED;
4643
}
4644
4645
/* Call the handler function */
4646
nih_error_push_context ();
4647
if (cgmanager_get_tasks_recursive (object->data, message, controller, cgroup, &output, &output_len) < 0) {
4648
NihError *err;
4649
4650
err = nih_error_get ();
4651
if (err->number == ENOMEM) {
4652
nih_free (err);
4653
nih_error_pop_context ();
4654
4655
return DBUS_HANDLER_RESULT_NEED_MEMORY;
4656
} else if (err->number == NIH_DBUS_ERROR) {
4657
NihDBusError *dbus_err = (NihDBusError *)err;
4658
4659
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
4660
nih_free (err);
4661
nih_error_pop_context ();
4662
4663
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
4664
4665
dbus_message_unref (reply);
4666
return DBUS_HANDLER_RESULT_HANDLED;
4667
} else {
4668
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
4669
nih_free (err);
4670
nih_error_pop_context ();
4671
4672
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
4673
4674
dbus_message_unref (reply);
4675
return DBUS_HANDLER_RESULT_HANDLED;
4676
}
4677
}
4678
nih_error_pop_context ();
4679
4680
/* If the sender doesn't care about a reply, don't bother wasting
4681
* effort constructing and sending one.
4682
*/
4683
if (dbus_message_get_no_reply (message->message))
4684
return DBUS_HANDLER_RESULT_HANDLED;
4685
4686
do {
4687
__label__ enomem;
4688
4689
/* Construct the reply message. */
4690
reply = dbus_message_new_method_return (message->message);
4691
if (! reply)
4692
goto enomem;
4693
4694
dbus_message_iter_init_append (reply, &iter);
4695
4696
/* Marshal an array onto the message */
4697
if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "i", &output_iter)) {
4698
dbus_message_unref (reply);
4699
reply = NULL;
4700
goto enomem;
4701
}
4702
4703
for (size_t output_i = 0; output_i < output_len; output_i++) {
4704
int32_t output_element;
4705
4706
output_element = output[output_i];
4707
4708
/* Marshal a int32_t onto the message */
4709
if (! dbus_message_iter_append_basic (&output_iter, DBUS_TYPE_INT32, &output_element)) {
4710
dbus_message_iter_abandon_container (&iter, &output_iter);
4711
dbus_message_unref (reply);
4712
reply = NULL;
4713
goto enomem;
4714
}
4715
}
4716
4717
if (! dbus_message_iter_close_container (&iter, &output_iter)) {
4718
dbus_message_unref (reply);
4719
reply = NULL;
4720
goto enomem;
4721
}
4722
enomem: __attribute__ ((unused));
4723
} while (! reply);
4724
4725
/* Send the reply, appending it to the outgoing queue. */
4726
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
4727
4728
dbus_message_unref (reply);
4729
4730
return DBUS_HANDLER_RESULT_HANDLED;
4731
}
4732
4733
4734
static DBusHandlerResult
4009
4735
cgmanager_org_linuxcontainers_cgmanager0_0_ListChildrenScm_method (NihDBusObject * object,
4010
4736
NihDBusMessage *message)
4011
4737
{
4662
5388
}
4663
5389
4664
5390
5391
static DBusHandlerResult
5392
cgmanager_org_linuxcontainers_cgmanager0_0_PruneScm_method (NihDBusObject * object,
5393
NihDBusMessage *message)
5394
{
5395
DBusMessageIter iter;
5396
DBusMessage * reply;
5397
char * controller;
5398
const char * controller_dbus;
5399
char * cgroup;
5400
const char * cgroup_dbus;
5401
int sockfd;
5402
5403
nih_assert (object != NULL);
5404
nih_assert (message != NULL);
5405
5406
/* Iterate the arguments to the message and demarshal into arguments
5407
* for our own function call.
5408
*/
5409
dbus_message_iter_init (message->message, &iter);
5410
5411
/* Demarshal a char * from the message */
5412
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
5413
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5414
"Invalid arguments to PruneScm method");
5415
if (! reply)
5416
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5417
5418
if (! dbus_connection_send (message->connection, reply, NULL)) {
5419
dbus_message_unref (reply);
5420
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5421
}
5422
5423
dbus_message_unref (reply);
5424
return DBUS_HANDLER_RESULT_HANDLED;
5425
}
5426
5427
dbus_message_iter_get_basic (&iter, &controller_dbus);
5428
5429
controller = nih_strdup (message, controller_dbus);
5430
if (! controller) {
5431
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5432
}
5433
5434
dbus_message_iter_next (&iter);
5435
5436
/* Demarshal a char * from the message */
5437
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
5438
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5439
"Invalid arguments to PruneScm method");
5440
if (! reply)
5441
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5442
5443
if (! dbus_connection_send (message->connection, reply, NULL)) {
5444
dbus_message_unref (reply);
5445
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5446
}
5447
5448
dbus_message_unref (reply);
5449
return DBUS_HANDLER_RESULT_HANDLED;
5450
}
5451
5452
dbus_message_iter_get_basic (&iter, &cgroup_dbus);
5453
5454
cgroup = nih_strdup (message, cgroup_dbus);
5455
if (! cgroup) {
5456
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5457
}
5458
5459
dbus_message_iter_next (&iter);
5460
5461
/* Demarshal a int from the message */
5462
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_UNIX_FD) {
5463
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5464
"Invalid arguments to PruneScm method");
5465
if (! reply)
5466
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5467
5468
if (! dbus_connection_send (message->connection, reply, NULL)) {
5469
dbus_message_unref (reply);
5470
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5471
}
5472
5473
dbus_message_unref (reply);
5474
return DBUS_HANDLER_RESULT_HANDLED;
5475
}
5476
5477
dbus_message_iter_get_basic (&iter, &sockfd);
5478
5479
dbus_message_iter_next (&iter);
5480
5481
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
5482
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5483
"Invalid arguments to PruneScm method");
5484
if (! reply)
5485
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5486
5487
if (! dbus_connection_send (message->connection, reply, NULL)) {
5488
dbus_message_unref (reply);
5489
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5490
}
5491
5492
dbus_message_unref (reply);
5493
return DBUS_HANDLER_RESULT_HANDLED;
5494
}
5495
5496
/* Call the handler function */
5497
nih_error_push_context ();
5498
if (cgmanager_prune_scm (object->data, message, controller, cgroup, sockfd) < 0) {
5499
NihError *err;
5500
5501
err = nih_error_get ();
5502
if (err->number == ENOMEM) {
5503
nih_free (err);
5504
nih_error_pop_context ();
5505
5506
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5507
} else if (err->number == NIH_DBUS_ERROR) {
5508
NihDBusError *dbus_err = (NihDBusError *)err;
5509
5510
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
5511
nih_free (err);
5512
nih_error_pop_context ();
5513
5514
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5515
5516
dbus_message_unref (reply);
5517
return DBUS_HANDLER_RESULT_HANDLED;
5518
} else {
5519
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
5520
nih_free (err);
5521
nih_error_pop_context ();
5522
5523
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5524
5525
dbus_message_unref (reply);
5526
return DBUS_HANDLER_RESULT_HANDLED;
5527
}
5528
}
5529
nih_error_pop_context ();
5530
5531
/* If the sender doesn't care about a reply, don't bother wasting
5532
* effort constructing and sending one.
5533
*/
5534
if (dbus_message_get_no_reply (message->message))
5535
return DBUS_HANDLER_RESULT_HANDLED;
5536
5537
do {
5538
__label__ enomem;
5539
5540
/* Construct the reply message. */
5541
reply = dbus_message_new_method_return (message->message);
5542
if (! reply)
5543
goto enomem;
5544
5545
dbus_message_iter_init_append (reply, &iter);
5546
enomem: __attribute__ ((unused));
5547
} while (! reply);
5548
5549
/* Send the reply, appending it to the outgoing queue. */
5550
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5551
5552
dbus_message_unref (reply);
5553
5554
return DBUS_HANDLER_RESULT_HANDLED;
5555
}
5556
5557
5558
static DBusHandlerResult
5559
cgmanager_org_linuxcontainers_cgmanager0_0_Prune_method (NihDBusObject * object,
5560
NihDBusMessage *message)
5561
{
5562
DBusMessageIter iter;
5563
DBusMessage * reply;
5564
char * controller;
5565
const char * controller_dbus;
5566
char * cgroup;
5567
const char * cgroup_dbus;
5568
5569
nih_assert (object != NULL);
5570
nih_assert (message != NULL);
5571
5572
/* Iterate the arguments to the message and demarshal into arguments
5573
* for our own function call.
5574
*/
5575
dbus_message_iter_init (message->message, &iter);
5576
5577
/* Demarshal a char * from the message */
5578
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
5579
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5580
"Invalid arguments to Prune method");
5581
if (! reply)
5582
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5583
5584
if (! dbus_connection_send (message->connection, reply, NULL)) {
5585
dbus_message_unref (reply);
5586
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5587
}
5588
5589
dbus_message_unref (reply);
5590
return DBUS_HANDLER_RESULT_HANDLED;
5591
}
5592
5593
dbus_message_iter_get_basic (&iter, &controller_dbus);
5594
5595
controller = nih_strdup (message, controller_dbus);
5596
if (! controller) {
5597
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5598
}
5599
5600
dbus_message_iter_next (&iter);
5601
5602
/* Demarshal a char * from the message */
5603
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
5604
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5605
"Invalid arguments to Prune method");
5606
if (! reply)
5607
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5608
5609
if (! dbus_connection_send (message->connection, reply, NULL)) {
5610
dbus_message_unref (reply);
5611
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5612
}
5613
5614
dbus_message_unref (reply);
5615
return DBUS_HANDLER_RESULT_HANDLED;
5616
}
5617
5618
dbus_message_iter_get_basic (&iter, &cgroup_dbus);
5619
5620
cgroup = nih_strdup (message, cgroup_dbus);
5621
if (! cgroup) {
5622
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5623
}
5624
5625
dbus_message_iter_next (&iter);
5626
5627
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
5628
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5629
"Invalid arguments to Prune method");
5630
if (! reply)
5631
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5632
5633
if (! dbus_connection_send (message->connection, reply, NULL)) {
5634
dbus_message_unref (reply);
5635
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5636
}
5637
5638
dbus_message_unref (reply);
5639
return DBUS_HANDLER_RESULT_HANDLED;
5640
}
5641
5642
/* Call the handler function */
5643
nih_error_push_context ();
5644
if (cgmanager_prune (object->data, message, controller, cgroup) < 0) {
5645
NihError *err;
5646
5647
err = nih_error_get ();
5648
if (err->number == ENOMEM) {
5649
nih_free (err);
5650
nih_error_pop_context ();
5651
5652
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5653
} else if (err->number == NIH_DBUS_ERROR) {
5654
NihDBusError *dbus_err = (NihDBusError *)err;
5655
5656
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
5657
nih_free (err);
5658
nih_error_pop_context ();
5659
5660
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5661
5662
dbus_message_unref (reply);
5663
return DBUS_HANDLER_RESULT_HANDLED;
5664
} else {
5665
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
5666
nih_free (err);
5667
nih_error_pop_context ();
5668
5669
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5670
5671
dbus_message_unref (reply);
5672
return DBUS_HANDLER_RESULT_HANDLED;
5673
}
5674
}
5675
nih_error_pop_context ();
5676
5677
/* If the sender doesn't care about a reply, don't bother wasting
5678
* effort constructing and sending one.
5679
*/
5680
if (dbus_message_get_no_reply (message->message))
5681
return DBUS_HANDLER_RESULT_HANDLED;
5682
5683
do {
5684
__label__ enomem;
5685
5686
/* Construct the reply message. */
5687
reply = dbus_message_new_method_return (message->message);
5688
if (! reply)
5689
goto enomem;
5690
5691
dbus_message_iter_init_append (reply, &iter);
5692
enomem: __attribute__ ((unused));
5693
} while (! reply);
5694
5695
/* Send the reply, appending it to the outgoing queue. */
5696
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5697
5698
dbus_message_unref (reply);
5699
5700
return DBUS_HANDLER_RESULT_HANDLED;
5701
}
5702
5703
5704
static DBusHandlerResult
5705
cgmanager_org_linuxcontainers_cgmanager0_0_ListControllers_method (NihDBusObject * object,
5706
NihDBusMessage *message)
5707
{
5708
DBusMessageIter iter;
5709
DBusMessage * reply;
5710
char ** output;
5711
DBusMessageIter output_iter;
5712
5713
nih_assert (object != NULL);
5714
nih_assert (message != NULL);
5715
5716
/* Iterate the arguments to the message and demarshal into arguments
5717
* for our own function call.
5718
*/
5719
dbus_message_iter_init (message->message, &iter);
5720
5721
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
5722
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5723
"Invalid arguments to ListControllers method");
5724
if (! reply)
5725
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5726
5727
if (! dbus_connection_send (message->connection, reply, NULL)) {
5728
dbus_message_unref (reply);
5729
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5730
}
5731
5732
dbus_message_unref (reply);
5733
return DBUS_HANDLER_RESULT_HANDLED;
5734
}
5735
5736
/* Call the handler function */
5737
nih_error_push_context ();
5738
if (cgmanager_list_controllers (object->data, message, &output) < 0) {
5739
NihError *err;
5740
5741
err = nih_error_get ();
5742
if (err->number == ENOMEM) {
5743
nih_free (err);
5744
nih_error_pop_context ();
5745
5746
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5747
} else if (err->number == NIH_DBUS_ERROR) {
5748
NihDBusError *dbus_err = (NihDBusError *)err;
5749
5750
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
5751
nih_free (err);
5752
nih_error_pop_context ();
5753
5754
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5755
5756
dbus_message_unref (reply);
5757
return DBUS_HANDLER_RESULT_HANDLED;
5758
} else {
5759
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
5760
nih_free (err);
5761
nih_error_pop_context ();
5762
5763
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5764
5765
dbus_message_unref (reply);
5766
return DBUS_HANDLER_RESULT_HANDLED;
5767
}
5768
}
5769
nih_error_pop_context ();
5770
5771
/* If the sender doesn't care about a reply, don't bother wasting
5772
* effort constructing and sending one.
5773
*/
5774
if (dbus_message_get_no_reply (message->message))
5775
return DBUS_HANDLER_RESULT_HANDLED;
5776
5777
do {
5778
__label__ enomem;
5779
5780
/* Construct the reply message. */
5781
reply = dbus_message_new_method_return (message->message);
5782
if (! reply)
5783
goto enomem;
5784
5785
dbus_message_iter_init_append (reply, &iter);
5786
5787
/* Marshal an array onto the message */
5788
if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &output_iter)) {
5789
dbus_message_unref (reply);
5790
reply = NULL;
5791
goto enomem;
5792
}
5793
5794
if (output) {
5795
for (size_t output_i = 0; output[output_i]; output_i++) {
5796
const char *output_element;
5797
5798
output_element = output[output_i];
5799
5800
/* Marshal a char * onto the message */
5801
if (! dbus_message_iter_append_basic (&output_iter, DBUS_TYPE_STRING, &output_element)) {
5802
dbus_message_iter_abandon_container (&iter, &output_iter);
5803
dbus_message_unref (reply);
5804
reply = NULL;
5805
goto enomem;
5806
}
5807
}
5808
}
5809
5810
if (! dbus_message_iter_close_container (&iter, &output_iter)) {
5811
dbus_message_unref (reply);
5812
reply = NULL;
5813
goto enomem;
5814
}
5815
enomem: __attribute__ ((unused));
5816
} while (! reply);
5817
5818
/* Send the reply, appending it to the outgoing queue. */
5819
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5820
5821
dbus_message_unref (reply);
5822
5823
return DBUS_HANDLER_RESULT_HANDLED;
5824
}
5825
5826
5827
static DBusHandlerResult
5828
cgmanager_org_linuxcontainers_cgmanager0_0_ListKeysScm_method (NihDBusObject * object,
5829
NihDBusMessage *message)
5830
{
5831
DBusMessageIter iter;
5832
DBusMessage * reply;
5833
char * controller;
5834
const char * controller_dbus;
5835
char * cgroup;
5836
const char * cgroup_dbus;
5837
int sockfd;
5838
5839
nih_assert (object != NULL);
5840
nih_assert (message != NULL);
5841
5842
/* Iterate the arguments to the message and demarshal into arguments
5843
* for our own function call.
5844
*/
5845
dbus_message_iter_init (message->message, &iter);
5846
5847
/* Demarshal a char * from the message */
5848
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
5849
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5850
"Invalid arguments to ListKeysScm method");
5851
if (! reply)
5852
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5853
5854
if (! dbus_connection_send (message->connection, reply, NULL)) {
5855
dbus_message_unref (reply);
5856
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5857
}
5858
5859
dbus_message_unref (reply);
5860
return DBUS_HANDLER_RESULT_HANDLED;
5861
}
5862
5863
dbus_message_iter_get_basic (&iter, &controller_dbus);
5864
5865
controller = nih_strdup (message, controller_dbus);
5866
if (! controller) {
5867
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5868
}
5869
5870
dbus_message_iter_next (&iter);
5871
5872
/* Demarshal a char * from the message */
5873
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
5874
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5875
"Invalid arguments to ListKeysScm method");
5876
if (! reply)
5877
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5878
5879
if (! dbus_connection_send (message->connection, reply, NULL)) {
5880
dbus_message_unref (reply);
5881
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5882
}
5883
5884
dbus_message_unref (reply);
5885
return DBUS_HANDLER_RESULT_HANDLED;
5886
}
5887
5888
dbus_message_iter_get_basic (&iter, &cgroup_dbus);
5889
5890
cgroup = nih_strdup (message, cgroup_dbus);
5891
if (! cgroup) {
5892
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5893
}
5894
5895
dbus_message_iter_next (&iter);
5896
5897
/* Demarshal a int from the message */
5898
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_UNIX_FD) {
5899
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5900
"Invalid arguments to ListKeysScm method");
5901
if (! reply)
5902
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5903
5904
if (! dbus_connection_send (message->connection, reply, NULL)) {
5905
dbus_message_unref (reply);
5906
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5907
}
5908
5909
dbus_message_unref (reply);
5910
return DBUS_HANDLER_RESULT_HANDLED;
5911
}
5912
5913
dbus_message_iter_get_basic (&iter, &sockfd);
5914
5915
dbus_message_iter_next (&iter);
5916
5917
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
5918
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
5919
"Invalid arguments to ListKeysScm method");
5920
if (! reply)
5921
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5922
5923
if (! dbus_connection_send (message->connection, reply, NULL)) {
5924
dbus_message_unref (reply);
5925
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5926
}
5927
5928
dbus_message_unref (reply);
5929
return DBUS_HANDLER_RESULT_HANDLED;
5930
}
5931
5932
/* Call the handler function */
5933
nih_error_push_context ();
5934
if (cgmanager_list_keys_scm (object->data, message, controller, cgroup, sockfd) < 0) {
5935
NihError *err;
5936
5937
err = nih_error_get ();
5938
if (err->number == ENOMEM) {
5939
nih_free (err);
5940
nih_error_pop_context ();
5941
5942
return DBUS_HANDLER_RESULT_NEED_MEMORY;
5943
} else if (err->number == NIH_DBUS_ERROR) {
5944
NihDBusError *dbus_err = (NihDBusError *)err;
5945
5946
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
5947
nih_free (err);
5948
nih_error_pop_context ();
5949
5950
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5951
5952
dbus_message_unref (reply);
5953
return DBUS_HANDLER_RESULT_HANDLED;
5954
} else {
5955
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
5956
nih_free (err);
5957
nih_error_pop_context ();
5958
5959
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5960
5961
dbus_message_unref (reply);
5962
return DBUS_HANDLER_RESULT_HANDLED;
5963
}
5964
}
5965
nih_error_pop_context ();
5966
5967
/* If the sender doesn't care about a reply, don't bother wasting
5968
* effort constructing and sending one.
5969
*/
5970
if (dbus_message_get_no_reply (message->message))
5971
return DBUS_HANDLER_RESULT_HANDLED;
5972
5973
do {
5974
__label__ enomem;
5975
5976
/* Construct the reply message. */
5977
reply = dbus_message_new_method_return (message->message);
5978
if (! reply)
5979
goto enomem;
5980
5981
dbus_message_iter_init_append (reply, &iter);
5982
enomem: __attribute__ ((unused));
5983
} while (! reply);
5984
5985
/* Send the reply, appending it to the outgoing queue. */
5986
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
5987
5988
dbus_message_unref (reply);
5989
5990
return DBUS_HANDLER_RESULT_HANDLED;
5991
}
5992
5993
5994
static DBusHandlerResult
5995
cgmanager_org_linuxcontainers_cgmanager0_0_ListKeys_method (NihDBusObject * object,
5996
NihDBusMessage *message)
5997
{
5998
DBusMessageIter iter;
5999
DBusMessage * reply;
6000
char * controller;
6001
const char * controller_dbus;
6002
char * cgroup;
6003
const char * cgroup_dbus;
6004
CgmanagerListKeysOutputElement **output;
6005
DBusMessageIter output_iter;
6006
6007
nih_assert (object != NULL);
6008
nih_assert (message != NULL);
6009
6010
/* Iterate the arguments to the message and demarshal into arguments
6011
* for our own function call.
6012
*/
6013
dbus_message_iter_init (message->message, &iter);
6014
6015
/* Demarshal a char * from the message */
6016
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
6017
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
6018
"Invalid arguments to ListKeys method");
6019
if (! reply)
6020
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6021
6022
if (! dbus_connection_send (message->connection, reply, NULL)) {
6023
dbus_message_unref (reply);
6024
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6025
}
6026
6027
dbus_message_unref (reply);
6028
return DBUS_HANDLER_RESULT_HANDLED;
6029
}
6030
6031
dbus_message_iter_get_basic (&iter, &controller_dbus);
6032
6033
controller = nih_strdup (message, controller_dbus);
6034
if (! controller) {
6035
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6036
}
6037
6038
dbus_message_iter_next (&iter);
6039
6040
/* Demarshal a char * from the message */
6041
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_STRING) {
6042
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
6043
"Invalid arguments to ListKeys method");
6044
if (! reply)
6045
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6046
6047
if (! dbus_connection_send (message->connection, reply, NULL)) {
6048
dbus_message_unref (reply);
6049
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6050
}
6051
6052
dbus_message_unref (reply);
6053
return DBUS_HANDLER_RESULT_HANDLED;
6054
}
6055
6056
dbus_message_iter_get_basic (&iter, &cgroup_dbus);
6057
6058
cgroup = nih_strdup (message, cgroup_dbus);
6059
if (! cgroup) {
6060
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6061
}
6062
6063
dbus_message_iter_next (&iter);
6064
6065
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
6066
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
6067
"Invalid arguments to ListKeys method");
6068
if (! reply)
6069
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6070
6071
if (! dbus_connection_send (message->connection, reply, NULL)) {
6072
dbus_message_unref (reply);
6073
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6074
}
6075
6076
dbus_message_unref (reply);
6077
return DBUS_HANDLER_RESULT_HANDLED;
6078
}
6079
6080
/* Call the handler function */
6081
nih_error_push_context ();
6082
if (cgmanager_list_keys (object->data, message, controller, cgroup, &output) < 0) {
6083
NihError *err;
6084
6085
err = nih_error_get ();
6086
if (err->number == ENOMEM) {
6087
nih_free (err);
6088
nih_error_pop_context ();
6089
6090
return DBUS_HANDLER_RESULT_NEED_MEMORY;
6091
} else if (err->number == NIH_DBUS_ERROR) {
6092
NihDBusError *dbus_err = (NihDBusError *)err;
6093
6094
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
6095
nih_free (err);
6096
nih_error_pop_context ();
6097
6098
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
6099
6100
dbus_message_unref (reply);
6101
return DBUS_HANDLER_RESULT_HANDLED;
6102
} else {
6103
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
6104
nih_free (err);
6105
nih_error_pop_context ();
6106
6107
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
6108
6109
dbus_message_unref (reply);
6110
return DBUS_HANDLER_RESULT_HANDLED;
6111
}
6112
}
6113
nih_error_pop_context ();
6114
6115
/* If the sender doesn't care about a reply, don't bother wasting
6116
* effort constructing and sending one.
6117
*/
6118
if (dbus_message_get_no_reply (message->message))
6119
return DBUS_HANDLER_RESULT_HANDLED;
6120
6121
do {
6122
__label__ enomem;
6123
6124
/* Construct the reply message. */
6125
reply = dbus_message_new_method_return (message->message);
6126
if (! reply)
6127
goto enomem;
6128
6129
dbus_message_iter_init_append (reply, &iter);
6130
6131
/* Marshal an array onto the message */
6132
if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(suuu)", &output_iter)) {
6133
dbus_message_unref (reply);
6134
reply = NULL;
6135
goto enomem;
6136
}
6137
6138
if (output) {
6139
for (size_t output_i = 0; output[output_i]; output_i++) {
6140
DBusMessageIter output_element_iter;
6141
const char * output_element_item0;
6142
uint32_t output_element_item1;
6143
uint32_t output_element_item2;
6144
uint32_t output_element_item3;
6145
const CgmanagerListKeysOutputElement *output_element;
6146
6147
output_element = output[output_i];
6148
6149
/* Marshal a structure onto the message */
6150
if (! dbus_message_iter_open_container (&output_iter, DBUS_TYPE_STRUCT, NULL, &output_element_iter)) {
6151
dbus_message_iter_abandon_container (&iter, &output_iter);
6152
dbus_message_unref (reply);
6153
reply = NULL;
6154
goto enomem;
6155
}
6156
6157
output_element_item0 = output_element->item0;
6158
6159
/* Marshal a char * onto the message */
6160
if (! dbus_message_iter_append_basic (&output_element_iter, DBUS_TYPE_STRING, &output_element_item0)) {
6161
dbus_message_iter_abandon_container (&output_iter, &output_element_iter);
6162
dbus_message_iter_abandon_container (&iter, &output_iter);
6163
dbus_message_unref (reply);
6164
reply = NULL;
6165
goto enomem;
6166
}
6167
6168
output_element_item1 = output_element->item1;
6169
6170
/* Marshal a uint32_t onto the message */
6171
if (! dbus_message_iter_append_basic (&output_element_iter, DBUS_TYPE_UINT32, &output_element_item1)) {
6172
dbus_message_iter_abandon_container (&output_iter, &output_element_iter);
6173
dbus_message_iter_abandon_container (&iter, &output_iter);
6174
dbus_message_unref (reply);
6175
reply = NULL;
6176
goto enomem;
6177
}
6178
6179
output_element_item2 = output_element->item2;
6180
6181
/* Marshal a uint32_t onto the message */
6182
if (! dbus_message_iter_append_basic (&output_element_iter, DBUS_TYPE_UINT32, &output_element_item2)) {
6183
dbus_message_iter_abandon_container (&output_iter, &output_element_iter);
6184
dbus_message_iter_abandon_container (&iter, &output_iter);
6185
dbus_message_unref (reply);
6186
reply = NULL;
6187
goto enomem;
6188
}
6189
6190
output_element_item3 = output_element->item3;
6191
6192
/* Marshal a uint32_t onto the message */
6193
if (! dbus_message_iter_append_basic (&output_element_iter, DBUS_TYPE_UINT32, &output_element_item3)) {
6194
dbus_message_iter_abandon_container (&output_iter, &output_element_iter);
6195
dbus_message_iter_abandon_container (&iter, &output_iter);
6196
dbus_message_unref (reply);
6197
reply = NULL;
6198
goto enomem;
6199
}
6200
6201
if (! dbus_message_iter_close_container (&output_iter, &output_element_iter)) {
6202
dbus_message_iter_abandon_container (&iter, &output_iter);
6203
dbus_message_unref (reply);
6204
reply = NULL;
6205
goto enomem;
6206
}
6207
}
6208
}
6209
6210
if (! dbus_message_iter_close_container (&iter, &output_iter)) {
6211
dbus_message_unref (reply);
6212
reply = NULL;
6213
goto enomem;
6214
}
6215
enomem: __attribute__ ((unused));
6216
} while (! reply);
6217
6218
/* Send the reply, appending it to the outgoing queue. */
6219
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
6220
6221
dbus_message_unref (reply);
6222
6223
return DBUS_HANDLER_RESULT_HANDLED;
6224
}
6225
6226
4665
6227
static int
4666
6228
cgmanager_org_linuxcontainers_cgmanager0_0_api_version_get (NihDBusObject * object,
4667
6229
NihDBusMessage * message,
Loggerhead is a web-based interface for Breezy
Version: 2.0.1