Codebase list realmd / upstream/0.1 service / realm-service.h
upstream/0.1

Tree @upstream/0.1 (Download .tar.gz)

realm-service.h @upstream/0.1 — raw · history · blame 

  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
/* realmd -- Realm configuration service
 *
 * Copyright 2012 Red Hat Inc
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 2 of the licence or (at
 * your option) any later version.
 *
 * See the included COPYING file for more information.
 *
 * Author: Stef Walter <stefw@gnome.org>
 */

#include "config.h"

#ifndef __REALM_SERVICE_H__
#define __REALM_SERVICE_H__

#include <gio/gio.h>

G_BEGIN_DECLS

#define REALM_TYPE_SERVICE            (realm_service_get_type ())
#define REALM_SERVICE(inst)           (G_TYPE_CHECK_INSTANCE_CAST ((inst), REALM_TYPE_SERVICE, RealmService))
#define REALM_IS_SERVICE(inst)        (G_TYPE_CHECK_INSTANCE_TYPE ((inst), REALM_TYPE_SERVICE))
#define REALM_SERVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), REALM_TYPE_SERVICE, RealmServiceClass))
#define REALM_IS_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), REALM_TYPE_SERVICE))
#define REALM_SERVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), REALM_TYPE_SERVICE, RealmServiceClass))

typedef struct _RealmService RealmService;
typedef struct _RealmServiceClass RealmServiceClass;

struct _RealmService {
	GDBusProxy parent;
};

struct _RealmServiceClass {
	GDBusProxyClass parent_class;

	void      (* enable)                    (RealmService *service,
	                                         GDBusMethodInvocation *invocation,
	                                         GAsyncReadyCallback callback,
	                                         gpointer user_data);

	gboolean  (* enable_finish)             (RealmService *service,
	                                         GAsyncResult *result,
	                                         GError **error);

	void      (* disable)                   (RealmService *service,
	                                         GDBusMethodInvocation *invocation,
	                                         GAsyncReadyCallback callback,
	                                         gpointer user_data);

	gboolean  (* disable_finish)            (RealmService *service,
	                                         GAsyncResult *result,
	                                         GError **error);

	void      (* restart)                   (RealmService *service,
	                                         GDBusMethodInvocation *invocation,
	                                         GAsyncReadyCallback callback,
	                                         gpointer user_data);

	gboolean  (* restart_finish)            (RealmService *service,
	                                         GAsyncResult *result,
	                                         GError **error);

	void      (* stop)                      (RealmService *service,
	                                         GDBusMethodInvocation *invocation,
	                                         GAsyncReadyCallback callback,
	                                         gpointer user_data);

	gboolean  (* stop_finish)               (RealmService *service,
	                                         GAsyncResult *result,
	                                         GError **error);
};

GType            realm_service_get_type                  (void) G_GNUC_CONST;

void             realm_service_new                       (const gchar *service_name,
                                                   GDBusMethodInvocation *invocation,
                                                   GAsyncReadyCallback callback,
                                                   gpointer user_data);

RealmService *   realm_service_new_finish         (GAsyncResult *result,
                                                   GError **error);

void             realm_service_enable             (RealmService *service,
                                                   GDBusMethodInvocation *invocation,
                                                   GAsyncReadyCallback callback,
                                                   gpointer user_data);

gboolean         realm_service_enable_finish      (RealmService *service,
                                                   GAsyncResult *result,
                                                   GError **error);

void             realm_service_disable            (RealmService *service,
                                                   GDBusMethodInvocation *invocation,
                                                   GAsyncReadyCallback callback,
                                                   gpointer user_data);

gboolean         realm_service_disable_finish     (RealmService *service,
                                                   GAsyncResult *result,
                                                   GError **error);

void             realm_service_restart            (RealmService *service,
                                                   GDBusMethodInvocation *invocation,
                                                   GAsyncReadyCallback callback,
                                                   gpointer user_data);

gboolean         realm_service_restart_finish     (RealmService *service,
                                                   GAsyncResult *result,
                                                   GError **error);

void             realm_service_stop               (RealmService *service,
                                                   GDBusMethodInvocation *invocation,
                                                   GAsyncReadyCallback callback,
                                                   gpointer user_data);

gboolean         realm_service_stop_finish        (RealmService *service,
                                                   GAsyncResult *result,
                                                   GError **error);

void             realm_service_enable_and_restart         (const gchar *service_name,
                                                           GDBusMethodInvocation *invocation,
                                                           GAsyncReadyCallback callback,
                                                           gpointer user_data);

gboolean         realm_service_enable_and_restart_finish  (GAsyncResult *result,
                                                           GError **error);

void             realm_service_disable_and_stop           (const gchar *service_name,
                                                           GDBusMethodInvocation *invocation,
                                                           GAsyncReadyCallback callback,
                                                           gpointer user_data);

gboolean         realm_service_disable_and_stop_finish    (GAsyncResult *result,
                                                           GError **error);


G_END_DECLS

#endif /* __REALM_KERBEROS_SERVICE_H__ */