gboolean
cockpit_handler_logout (CockpitWebServer *server,
CockpitWebServerRequestType reqtype,
const gchar *path,
GHashTable *headers,
GBytes *input,
CockpitWebResponse *response,
CockpitHandlerData *ws)
{
GIOStream *io_stream;
GHashTable *out_headers;
const gchar *body;
gboolean secure;
GBytes *content;
io_stream = cockpit_web_response_get_stream (response);
secure = !G_IS_SOCKET_CONNECTION (io_stream);
out_headers = cockpit_web_server_new_table ();
cockpit_auth_logout (ws->auth, headers, secure, out_headers);
body ="<html><head><title>Logged out</title></head>"
"<body>Logged out</body></html>";
content = g_bytes_new_static (body, strlen (body));
cockpit_web_response_content (response, out_headers, content, NULL);
g_bytes_unref (content);
g_hash_table_unref (out_headers);
return TRUE;
}
static void
on_login_complete (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
LoginResponse *lr = user_data;
GError *error = NULL;
CockpitWebService *service;
GIOStream *io_stream;
io_stream = cockpit_web_response_get_stream (lr->response);
service = cockpit_auth_login_finish (COCKPIT_AUTH (object), result,
!G_IS_SOCKET_CONNECTION (io_stream),
lr->headers, &error);
if (error)
{
cockpit_web_response_gerror (lr->response, lr->headers, error);
login_response_free (lr);
g_error_free (error);
}
else
{
cockpit_web_service_modules (service, "localhost", on_login_modules, lr);
g_object_unref (service);
}
}
static void
handle_login (CockpitHandlerData *data,
CockpitWebService *service,
const gchar *path,
GHashTable *headers,
CockpitWebResponse *response)
{
GHashTable *out_headers;
GIOStream *io_stream;
CockpitCreds *creds;
JsonObject *creds_json = NULL;
if (service)
{
out_headers = cockpit_web_server_new_table ();
creds = cockpit_web_service_get_creds (service);
creds_json = cockpit_creds_to_json (creds);
send_login_response (response, creds_json, out_headers);
g_hash_table_unref (out_headers);
json_object_unref (creds_json);
return;
}
io_stream = cockpit_web_response_get_stream (response);
cockpit_auth_login_async (data->auth, path,io_stream, headers,
on_login_complete, g_object_ref (response));
}
gboolean
cockpit_handler_login (CockpitWebServer *server,
const gchar *path,
GHashTable *headers,
CockpitWebResponse *response,
CockpitHandlerData *ws)
{
CockpitWebService *service;
CockpitCreds *creds;
gchar *remote_peer = NULL;
GHashTable *out_headers;
GIOStream *io_stream;
service = cockpit_auth_check_cookie (ws->auth, headers);
if (service == NULL)
{
io_stream = cockpit_web_response_get_stream (response);
remote_peer = get_remote_address (io_stream);
cockpit_auth_login_async (ws->auth, headers, remote_peer, on_login_complete,
g_object_ref (response));
g_free (remote_peer);
}
else
{
out_headers = cockpit_web_server_new_table ();
creds = cockpit_web_service_get_creds (service);
send_login_response (response, creds, out_headers);
g_hash_table_unref (out_headers);
g_object_unref (service);
}
/* no response yet */
return TRUE;
}
static void
on_login_complete (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
CockpitWebResponse *response = user_data;
GError *error = NULL;
CockpitWebService *service;
CockpitAuthFlags flags = 0;
CockpitCreds *creds;
GHashTable *headers;
GIOStream *io_stream;
io_stream = cockpit_web_response_get_stream (response);
if (G_IS_SOCKET_CONNECTION (io_stream))
flags |= COCKPIT_AUTH_COOKIE_INSECURE;
headers = cockpit_web_server_new_table ();
service = cockpit_auth_login_finish (COCKPIT_AUTH (object), result, flags, headers, &error);
if (error)
{
cockpit_web_response_gerror (response, headers, error);
g_error_free (error);
}
else
{
creds = cockpit_web_service_get_creds (service);
send_login_response (response, creds, headers);
g_object_unref (service);
}
g_hash_table_unref (headers);
g_object_unref (response);
}
static void
handle_login (CockpitHandlerData *data,
CockpitWebService *service,
const gchar *path,
GHashTable *headers,
CockpitWebResponse *response)
{
GHashTable *out_headers;
gchar *remote_peer = NULL;
GIOStream *io_stream;
CockpitCreds *creds;
if (service)
{
out_headers = cockpit_web_server_new_table ();
creds = cockpit_web_service_get_creds (service);
send_login_response (response, creds, out_headers);
g_hash_table_unref (out_headers);
}
else
{
io_stream = cockpit_web_response_get_stream (response);
remote_peer = get_remote_address (io_stream);
cockpit_auth_login_async (data->auth, path, headers, remote_peer,
on_login_complete, g_object_ref (response));
g_free (remote_peer);
}
}
static void
on_web_response_done (CockpitWebResponse *response,
gboolean reusable,
gpointer user_data)
{
CockpitWebServer *self = user_data;
GIOStream *io;
io = cockpit_web_response_get_stream (response);
if (reusable)
cockpit_request_start (self, io, FALSE);
else
close_io_stream (io);
}
static void
on_login_complete (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
CockpitWebResponse *response = user_data;
GError *error = NULL;
JsonObject *response_data = NULL;
GHashTable *headers;
GIOStream *io_stream;
GBytes *content;
io_stream = cockpit_web_response_get_stream (response);
headers = cockpit_web_server_new_table ();
response_data = cockpit_auth_login_finish (COCKPIT_AUTH (object), result,
io_stream, headers, &error);
/* Never cache a login response */
cockpit_web_response_set_cache_type (response, COCKPIT_WEB_RESPONSE_NO_CACHE);
if (error)
{
if (response_data)
{
g_hash_table_insert (headers, g_strdup ("Content-Type"), g_strdup ("application/json"));
content = cockpit_json_write_bytes (response_data);
cockpit_web_response_headers_full (response, 401, "Authentication required", -1, headers);
cockpit_web_response_queue (response, content);
cockpit_web_response_complete (response);
g_bytes_unref (content);
}
else
{
cockpit_web_response_gerror (response, headers, error);
}
g_error_free (error);
}
else
{
send_login_response (response, response_data, headers);
}
if (response_data)
json_object_unref (response_data);
g_hash_table_unref (headers);
g_object_unref (response);
}
gboolean
cockpit_handler_login (CockpitWebServer *server,
CockpitWebServerRequestType reqtype,
const gchar *path,
GHashTable *headers,
GBytes *input,
CockpitWebResponse *response,
CockpitHandlerData *ws)
{
CockpitWebService *service;
gchar *remote_peer = NULL;
GIOStream *io_stream;
LoginResponse *lr;
lr = g_new0 (LoginResponse, 1);
lr->response = g_object_ref (response);
lr->headers = cockpit_web_server_new_table ();
if (reqtype == COCKPIT_WEB_SERVER_REQUEST_GET)
{
service = cockpit_auth_check_cookie (ws->auth, headers);
if (service == NULL)
{
cockpit_web_response_error (response, 401, NULL, NULL);
login_response_free (lr);
}
else
{
cockpit_web_service_modules (service, "localhost", on_login_modules, lr);
g_object_unref (service);
/* no response yet */
}
}
else if (reqtype == COCKPIT_WEB_SERVER_REQUEST_POST)
{
io_stream = cockpit_web_response_get_stream (response);
remote_peer = get_remote_address (io_stream);
cockpit_auth_login_async (ws->auth, headers, input, remote_peer,
on_login_complete, lr);
g_free (remote_peer);
/* no response yet */
}
return TRUE;
}
static gboolean
mock_http_connection (CockpitWebResponse *response)
{
GIOStream *io;
GBytes *bytes;
gchar *output;
/* Lets caller have an indication of which IO stream is being used */
io = cockpit_web_response_get_stream (response);
output = g_strdup_printf ("%p", io);
bytes = g_bytes_new_take (output, strlen (output));
cockpit_web_response_content (response, NULL, bytes, NULL);
g_bytes_unref (bytes);
return TRUE;
}
