ipa_subdomains.c revision 249d3b8c72798a8eb081b620cc94072b3e8d6351
/*
SSSD
IPA Subdomains Module
Authors:
Sumit Bose <sbose@redhat.com>
Copyright (C) 2011 Red Hat
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "providers/ldap/sdap_async.h"
#include "providers/ipa/ipa_subdomains.h"
#include "providers/ipa/ipa_common.h"
#include <ctype.h>
#define SUBDOMAINS_FILTER "objectclass=ipaNTTrustedDomain"
#define MASTER_DOMAIN_FILTER "objectclass=ipaNTDomainAttrs"
#define RANGE_FILTER "objectclass=ipaIDRange"
#define IPA_CN "cn"
#define IPA_FLATNAME "ipaNTFlatName"
#define IPA_SID "ipaNTSecurityIdentifier"
#define IPA_TRUSTED_DOMAIN_SID "ipaNTTrustedDomainSID"
#define IPA_BASE_ID "ipaBaseID"
#define IPA_ID_RANGE_SIZE "ipaIDRangeSize"
#define IPA_BASE_RID "ipaBaseRID"
#define IPA_SECONDARY_BASE_RID "ipaSecondaryBaseRID"
#define OBJECTCLASS "objectClass"
/* do not refresh more often than every 5 seconds for now */
#define IPA_SUBDOMAIN_REFRESH_LIMIT 5
/* refresh automatically every 4 hours */
/* the directory domain - realm mappings are written to */
enum ipa_subdomains_req_type {
IPA_SUBDOMAINS_MAX /* Counter */
};
struct ipa_subdomains_req_params {
const char *filter;
const char *attrs[8];
};
struct ipa_subdomains_ctx {
struct sdap_id_ctx *sdap_id_ctx;
struct sdap_search_base **search_bases;
struct sdap_search_base **master_search_bases;
struct sdap_search_base **ranges_search_bases;
struct tevent_timer *timer_event;
/* subdomain map cache */
int num_subdoms;
struct sysdb_subdom *subdoms;
};
{
if (be_req) {
}
}
struct sysdb_attrs **reply,
struct range_info ***_range_list)
{
const char *value;
size_t c;
int ret;
if (range_list == NULL) {
return ENOMEM;
}
for (c = 0; c < count; c++) {
if (range_list[c] == NULL) {
goto done;
}
goto done;
}
goto done;
}
value);
goto done;
}
goto done;
}
&range_list[c]->base_id);
goto done;
}
&range_list[c]->id_range_size);
goto done;
}
&range_list[c]->base_rid);
goto done;
}
&range_list[c]->secondary_base_rid);
goto done;
}
}
range_list[c] = NULL;
done:
}
return ret;
}
{
char *realm;
char *p;
if (!realm) {
return NULL;
}
for (p = realm; *p; p++) {
*p = toupper(*p);
}
return realm;
}
struct sysdb_attrs *attrs,
struct sysdb_subdom *subdom)
{
const char *value;
int ret;
return ret;
}
return ENOMEM;
}
return EINVAL;
}
/* Add Realm as upper(domain name), this is generally always correct
* with AD domains */
return ENOMEM;
}
}
if (ret) {
return ret;
}
/* in theory this may change, it should never happen, so we will log a
* warning if it does, but we will allow it for now */
("Flat name for subdomain changed!\n"));
}
}
return ENOMEM;
}
}
if (ret) {
return ret;
}
/* in theory this may change, it should never happen, so we will log a
* warning if it does, but we will allow it for now */
("ID for subdomain changed!\n"));
}
}
return ENOMEM;
}
}
return EOK;
}
static errno_t
struct sysdb_subdom *subdoms)
{
const char *mapping_file;
int fd = -1;
size_t i;
if (!mapping_file) {
goto done;
}
goto done;
}
if (fd < 0) {
"mappings failed.", tmp_file));
goto done;
}
if (!fstream) {
if (ret != 0) {
/* Nothing to do here, just report the failure */
}
goto done;
}
if (ret < 0) {
goto done;
}
for (i = 0; i < num_subdoms; i++) {
if (ret < 0) {
goto done;
}
}
if (ret != 0) {
goto done;
}
if (ret == -1) {
goto done;
}
if (ret == -1) {
goto done;
}
done:
if (fstream) {
if (err != 0) {
/* Nothing to do here, just report the failure */
}
}
if (tmp_file) {
if (err < 0) {
("Could not remove file [%s]: [%d]: %s",
}
}
return ret;
}
bool *changes)
{
const char *value;
int c, h;
int ret;
int i, j;
/* check existing subdoms in cache */
for (i = 0, h = 0; i < ctx->num_subdoms; i++) {
for (c = 0; c < count; c++) {
if (handled[c]) {
continue;
}
goto done;
}
break;
}
}
if (c >= count) {
/* ok this subdomain does not exist anymore, let's clean up */
}
ctx->num_subdoms--;
i--;
} else {
/* ok let's try to update it */
if (ret) {
goto done;
}
handled[c] = true;
h++;
}
}
if (count == h) {
/* all domains were already accounted for and have been updated */
goto done;
}
/* if we get here it means we have changes to the subdomains list */
*changes = true;
/* add space for unhandled domains */
c = count - h;
struct sysdb_subdom,
ctx->num_subdoms + c);
goto done;
}
for (c = 0; c < count; c++) {
if (handled[c]) {
continue;
}
i = ctx->num_subdoms;
if (ret) {
goto done;
}
ctx->num_subdoms++;
}
done:
ctx->last_refreshed = 0;
ctx->num_subdoms = 0;
} else {
}
return ret;
}
struct ipa_subdomains_req_ctx {
struct ipa_subdomains_ctx *sd_ctx;
struct sdap_id_op *sdap_op;
char *current_filter;
struct sdap_search_base **search_bases;
int search_base_iter;
struct sysdb_attrs **reply;
};
static errno_t
enum ipa_subdomains_req_type type);
static struct ipa_subdomains_req_params subdomain_requests[] = {
},
},
{ RANGE_FILTER,
{ OBJECTCLASS, IPA_CN,
}
}
};
/* NOTE: be_req can be NULL, this is used by the online callback to refresh
* subdomains without any request coming from a frontend */
{
struct tevent_req *req;
int dp_error = DP_ERR_FATAL;
int ret;
goto done;
}
req_ctx->search_base_iter = 0;
req_ctx->reply_count = 0;
goto done;
}
goto done;
}
return;
done:
}
}
{
int ret;
int dp_error = DP_ERR_FATAL;
struct ipa_subdomains_req_ctx *ctx;
if (ret) {
if (dp_error == DP_ERR_OFFLINE) {
("No IPA server is available, cannot get the "
"subdomain list while offline\n"));
/* FIXME: return saved results ?? */
} else {
("Failed to connect to IPA server: [%d](%s)\n",
}
goto fail;
}
goto fail;
}
return;
fail:
}
static errno_t
enum ipa_subdomains_req_type type)
{
struct tevent_req *req;
struct sdap_search_base *base;
struct ipa_subdomains_req_params *params;
if (type >= IPA_SUBDOMAINS_MAX) {
return EINVAL;
}
return EOK;
}
return ENOMEM;
}
SDAP_SEARCH_TIMEOUT), false);
return ENOMEM;
}
return EAGAIN;
}
{
int ret;
struct ipa_subdomains_req_ctx *ctx;
bool refresh_has_changes = false;
} else {
}
goto done;
}
if (reply_count) {
goto done;
}
reply_count * sizeof(struct sysdb_attrs *));
}
ctx->search_base_iter++;
return;
goto done;
}
goto done;
}
if (refresh_has_changes) {
goto done;
}
("ipa_subdomains_write_mappings failed.\n"));
}
}
ctx->search_base_iter = 0;
return;
goto done;
}
done:
}
{
int dp_error = DP_ERR_FATAL;
struct ipa_subdomains_req_ctx *ctx;
struct sysdb_subdom *domain_info;
} else {
}
goto done;
}
("ipa_ranges_parse_results request failed.\n"));
goto done;
}
goto done;
}
goto done;
}
ctx->search_base_iter = 0;
return;
goto done;
}
} else {
}
done:
}
}
{
int dp_error = DP_ERR_FATAL;
struct ipa_subdomains_req_ctx *ctx;
struct sysdb_subdom *domain_info;
const char *tmp_str;
goto done;
}
if (reply_count) {
if (domain_info == NULL) {
goto done;
}
goto done;
}
goto done;
}
goto done;
}
goto done;
}
goto done;
} else {
ctx->search_base_iter++;
return;
goto done;
}
/* Right now we know there has been an error
* and we don't have the master domain record
*/
goto done;
}
done:
}
}
static void ipa_subdom_online_cb(void *pvt);
struct tevent_timer *te,
struct timeval current_time,
void *pvt)
{
}
static void ipa_subdom_online_cb(void *pvt)
{
struct ipa_subdomains_ctx *ctx;
if (!ctx) {
return;
}
if (!ctx->timer_event) {
}
}
static void ipa_subdom_offline_cb(void *pvt)
{
struct ipa_subdomains_ctx *ctx;
if (ctx) {
}
}
{
struct ipa_subdomains_ctx *ctx;
struct ipa_subdomains_ctx);
if (!ctx) {
return;
}
return;
}
}
struct bet_ops ipa_subdomains_ops = {
};
struct ipa_id_ctx *id_ctx,
void **pvt_data)
{
struct ipa_subdomains_ctx *ctx;
int ret;
return ENOMEM;
}
*ops = &ipa_subdomains_ops;
}
}
return EOK;
}