static CockpitAuthenticated *
authenticated_for_headers (CockpitAuth *self,
GHashTable *in_headers)
{
gchar *cookie = NULL;
gchar *raw = NULL;
const char *prefix = "v=2;k=";
CockpitAuthenticated *ret = NULL;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (in_headers != NULL, FALSE);
raw = cockpit_web_server_parse_cookie (in_headers, "cockpit");
if (raw)
{
cookie = base64_decode_string (raw);
if (cookie != NULL)
{
if (g_str_has_prefix (cookie, prefix))
ret = g_hash_table_lookup (self->authenticated, cookie);
else
g_debug ("invalid or unsupported cookie: %s", cookie);
g_free (cookie);
}
g_free (raw);
}
return ret;
}
static CockpitAuthenticated *
authenticated_for_headers (CockpitAuth *self,
GHashTable *in_headers)
{
gs_unref_hashtable GHashTable *cookies = NULL;
gs_free gchar *cookie = NULL;
const char *prefix = "v=2;k=";
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (in_headers != NULL, FALSE);
if (!cockpit_web_server_parse_cookies (in_headers, &cookies, NULL))
return NULL;
cookie = base64_decode_string (g_hash_table_lookup (cookies, "CockpitAuth"));
if (cookie == NULL)
return NULL;
if (!g_str_has_prefix (cookie, prefix))
{
g_debug ("invalid or unsupported cookie: %s", cookie);
return NULL;
}
return g_hash_table_lookup (self->authenticated, cookie);
}
CockpitCreds *
cockpit_auth_check_cookie (CockpitAuth *auth,
GHashTable *in_headers)
{
gs_unref_hashtable GHashTable *cookies = NULL;
gs_free gchar *auth_cookie = NULL;
g_return_val_if_fail (auth != NULL, FALSE);
g_return_val_if_fail (in_headers != NULL, FALSE);
if (!cockpit_web_server_parse_cookies (in_headers, &cookies, NULL))
return NULL;
auth_cookie = base64_decode_string (g_hash_table_lookup (cookies, "CockpitAuth"));
if (auth_cookie == NULL)
return NULL;
return cookie_to_creds (auth, auth_cookie);
}
gboolean
cockpit_auth_check_headers (CockpitAuth *auth,
GHashTable *headers,
char **out_user,
char **out_password)
{
gs_unref_hashtable GHashTable *cookies = NULL;
gs_free gchar *auth_cookie = NULL;
const char *prefix = "v=2;k=";
if (out_user)
*out_user = NULL;
if (out_password)
*out_password = NULL;
if (auth == NULL)
{
*out_user = g_strdup (g_get_user_name ());
*out_password = g_strdup ("<noauth>");
return TRUE;
}
if (!cockpit_web_server_parse_cookies (headers, &cookies, NULL))
return FALSE;
auth_cookie = base64_decode_string (g_hash_table_lookup (cookies, "CockpitAuth"));
if (auth_cookie == NULL)
return FALSE;
if (!g_str_has_prefix (auth_cookie, prefix))
{
g_debug ("invalid or unsupported cookie: %s", auth_cookie);
return FALSE;
}
return authenticated_id_to_user (auth, auth_cookie + strlen (prefix),
out_user, out_password);
}
static int
_httpd_decode_authorization(const char *value, char **user, char **pass)
{
unsigned char *tmp, *tmp2;
size_t len;
len = strlen(value) * 2;
if (!(tmp = (char *) calloc(1, len)))
{
log_error("calloc failed (%s)", strerror(errno));
return -1;
}
value = strstr(value, " ") + 1;
log_verbose("Authorization (base64) = \"%s\"", value);
base64_decode_string(value, tmp);
log_verbose("Authorization (ascii) = \"%s\"", tmp);
if ((tmp2 = strstr(tmp, ":")))
{
*tmp2++ = '\0';
*pass = strdup(tmp2);
}
else
{
*pass = strdup("");
}
*user = strdup(tmp);
free(tmp);
return 0;
}
/** Try to convert a string to the given OmlValueT and store it an OmlValueU.
*
* Storage for value should have already been cleared (e.g., with
* oml_value_set_type(), oml_value_reset() omlc_reset_string() or
* omlc_reset_blob() if appropriate).
*
* Assumes the destination OmlValueU has been properly reset.
*
* \param value pointer to output OmlValue
* \param type type of data to get from the string
* \param value_s input string
* \return 0 on success, -1 otherwise (e.g., conversion error)
* \see oml_value_from_s, oml_value_from_typed_s
* \see oml_value_set_type, oml_value_reset, omlc_reset_string, omlc_reset_blob
*/
static int
oml_value_ut_from_s (OmlValueU *value, OmlValueT type, const char *value_s)
{
char *s, *eptr;
ssize_t n;
size_t s_sz, blob_sz, nof_elts, bytes;
uint8_t *blob;
oml_guid_t c;
char *p;
char *q;
errno = 0; /* Not all paths manipulate errno, so make sure its value is reset */
switch (type) {
case OML_LONG_VALUE:
logwarn("%s(): OML_LONG_VALUE is deprecated, please use OML_INT32_VALUE instead\n", __FUNCTION__);
omlc_set_long (*value, strtol (value_s, NULL, 0));
break;
case OML_INT32_VALUE:
omlc_set_int32 (*value, strtol (value_s, NULL, 0));
break;
case OML_UINT32_VALUE:
omlc_set_uint32 (*value, strtoul (value_s, NULL, 0));
break;
case OML_INT64_VALUE:
omlc_set_int64 (*value, strtoll (value_s, NULL, 0));
break;
case OML_UINT64_VALUE:
omlc_set_uint64 (*value, strtoull (value_s, NULL, 0));
break;
case OML_DOUBLE_VALUE: {
omlc_set_double (*value, strtod (value_s, &eptr));
if (eptr == value_s) {
omlc_set_double (*value, NAN);
}
break;
}
case OML_STRING_VALUE:
s = oml_malloc(strlen(value_s)+1);
n = backslash_decode(value_s, s);
omlc_reset_string(*value);
omlc_set_string(*value, s);
omlc_set_string_size(*value,n+1);
break;
case OML_DATETIME_VALUE:
s = oml_malloc(strlen(value_s)+1);
n = backslash_decode(value_s, s);
omlc_reset_string(*value);
omlc_set_string(*value, s);
omlc_set_string_size(*value,n+1);
break;
case OML_BLOB_VALUE:
omlc_reset_blob(*value);
s_sz = base64_validate_string(value_s);
if(s_sz != -1) {
blob_sz = base64_size_blob(s_sz);
blob = oml_malloc(blob_sz);
base64_decode_string(s_sz, value_s, blob_sz, blob);
omlc_set_blob_ptr(*value, blob);
omlc_set_blob_length(*value, blob_sz);
omlc_set_blob_size(*value, blob_sz);
}
break;
case OML_GUID_VALUE:
omlc_string_to_guid(value_s, &c);
omlc_set_guid(*value, c);
break;
case OML_BOOL_VALUE:
omlc_set_bool(*value, oml_value_string_to_bool(value_s));
break;
case OML_VECTOR_DOUBLE_VALUE:
omlc_reset_vector(*value);
nof_elts = strtod(value_s, &p);
if(p - value_s) {
size_t i, bytes;
double *elts = oml_calloc(nof_elts, sizeof(double));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtod(p, &q);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [double] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(double);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(double));
} else {
logerror("%s(): out of memory reading [double] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [double] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_INT32_VALUE:
omlc_reset_vector(*value);
nof_elts = strtol(value_s, &p, 0);
if(p - value_s) {
size_t i;
int32_t *elts = oml_calloc(nof_elts, sizeof(int32_t));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtol(p, &q, 0);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [int32] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(int32_t);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(int32_t));
} else {
logerror("%s(): out of memory reading [int32] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [int32] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_UINT32_VALUE:
omlc_reset_vector(*value);
nof_elts = strtoul(value_s, &p, 0);
if(p - value_s) {
size_t i;
uint32_t *elts = oml_calloc(nof_elts, sizeof(uint32_t));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtoul(p, &q, 0);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [uint32] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(uint32_t);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(uint32_t));
} else {
logerror("%s(): out of memory reading [uint32] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [uint32] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_INT64_VALUE:
omlc_reset_vector(*value);
nof_elts = strtoll(value_s, &p, 0);
if(p - value_s) {
size_t i;
int64_t *elts = oml_calloc(nof_elts, sizeof(int64_t));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtoll(p, &q, 0);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [int64] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(int64_t);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(int64_t));
} else {
logerror("%s(): out of memory reading [int64] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [int64] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_UINT64_VALUE:
omlc_reset_vector(*value);
nof_elts = strtoull(value_s, &p, 0);
if(p - value_s) {
size_t i;
uint64_t *elts = oml_calloc(nof_elts, sizeof(uint64_t));
if(elts) {
for(i = 0; i < nof_elts; i++) {
elts[i] = strtoull(p, &q, 0);
if(q - p)
p = q;
else {
oml_free(elts);
logerror("%s(): bad [uint64] vector element '%s'\n", __FUNCTION__, p);
return -1;
}
}
bytes = nof_elts * sizeof(uint64_t);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(uint64_t));
} else {
logerror("%s(): out of memory reading [uint64] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [uint64] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
case OML_VECTOR_BOOL_VALUE:
omlc_reset_vector(*value);
nof_elts = strtoul(value_s, &p, 0);
if(p - value_s) {
char *n;
size_t i;
bool *elts = oml_calloc(nof_elts, sizeof(bool));
if(elts) {
for(i = 0; i < nof_elts; i++) {
char *v = strtok_r(p, " ", &n);
if(v) {
elts[i] = strncasecmp(v, "false", strlen(v));
p = n;
} else {
oml_free(elts);
logerror("%s(): bad [bool] '%s'\n", __FUNCTION__, p);
return -1;
}
}
omlc_set_vector_bool(*value, elts, nof_elts);
bytes = nof_elts * sizeof(bool);
omlc_set_vector_ptr(*value, elts);
omlc_set_vector_length(*value, bytes);
omlc_set_vector_size(*value, bytes);
omlc_set_vector_nof_elts(*value, nof_elts);
omlc_set_vector_elt_size(*value, sizeof(bool));
} else {
logerror("%s(): out of memory reading [bool] of size %zu\n", __FUNCTION__, nof_elts);
return -1;
}
} else {
logerror("%s(): bad [bool] size '%s'\n", __FUNCTION__, value_s);
return -1;
}
break;
default:
logerror("%s() for type '%d' not implemented to convert '%s'\n", __FUNCTION__, type, value_s);
return -1;
}
if (errno == ERANGE) {
logerror("%s(): underflow or overlow converting value from string '%s'\n", __FUNCTION__, value_s);
return -1;
}
return 0;
}
