/****** sgeobj/href/href_list_add() *******************************************
* NAME
* href_list_add() -- Add host or hostgroup reference.
*
* SYNOPSIS
* bool
* href_list_add(lList **this_list, lList **answer_list,
* const char *host_or_group)
*
* FUNCTION
* Add a host or hostgroup given by 'host_or_group' into the list
* 'this_list'. If the function is successfull then the function
* returns 'true' otherwise it will add an entry into 'answer_list'
* and return with 'false'. If 'this_list' does not exist than it
* will be created.
*
* INPUTS
* lList **this_list - HR_Type list
* lList **answer_list - AN_Type list
* const char *host_or_group - host or group name
*
* RESULT
* bool - error state
* true - Success
* false - Error
*******************************************************************************/
bool
href_list_add(lList **this_list, lList **answer_list, const char *host_or_group)
{
bool ret = true;
DENTER(HOSTREF_LAYER, "href_list_add");
if (this_list != NULL && host_or_group != NULL) {
if (!href_list_has_member(*this_list, host_or_group)) {
lListElem *h_or_g; /* HR_Type */
h_or_g = lAddElemHost(this_list, HR_name, host_or_group, HR_Type);
if (h_or_g == NULL) {
answer_list_add(answer_list, MSG_SGETEXT_NOMEM,
STATUS_EMALLOC, ANSWER_QUALITY_ERROR);
ret = false;
}
}
} else {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_INAVLID_PARAMETER_IN_S, SGE_FUNC));
answer_list_add(answer_list, SGE_EVENT,
STATUS_ERROR1, ANSWER_QUALITY_ERROR);
ret = false;
}
DEXIT;
return ret;
}
/****** sge_utility/verify_str_key() *******************************************
* NAME
* verify_str_key() -- Generic function for verifying object names
*
* SYNOPSIS
* an_status_t verify_str_key(lList **alpp, const char *str, size_t
* str_length, const char *name, int table)
*
* FUNCTION
* Verifies object names. The follwing verification tables are
* used
*
* QSUB_TABLE job account strings
* (see qsub(1) -A for characters not allowed)
* QSUB_TABLE job name
* (see qsub(1) -N for characters not allowed)
* KEY_TABLE parallel environemnt names
* (see sge_pe(5))
* KEY_TABLE calendar names
* (see calendar_conf(5))
* KEY_TABLE cluster queue names
* (see queue_conf(5))
* KEY_TABLE project names
* (see project(5))
* KEY_TABLE userset names
* (see access_list(5))
* KEY_TABLE department names
* (see access_list(5))
* KEY_TABLE checkpoint interface name
* (see checkpoint(5))
* KEY_TABLE user name
* (see user(5))
* KEY_TABLE hostgroup names
* (see hostgroup(5))
*
* KEY_TABLE event client name (internal purposes only)
* KEY_TABLE JAPI session key (internal purposes only)
*
* Note, there is test_sge_utility
*
* INPUTS
* lList **alpp - answer list
* const char *str - string to be verified
* size_t str_length - length of the string to be verified
* const char *name - verbal description of the object
* int table - verification table to be used
*
* RESULT
* an_status_t - STATUS_OK upon success
*
* NOTES
* MT-NOTE: verify_str_key() is MT safe
*
* SEE ALSO
* There is a module test (test_sge_utility) for verify_str_key().
*******************************************************************************/
an_status_t verify_str_key(
lList **alpp, const char *str, size_t str_length, const char *name, int table)
{
static const char *begin_strings[2][3];
static const char *mid_strings[2][20];
static char begin_chars[2][3] =
{ { '.', '#', 0 },
{ 0, 0, 0 } };
static const char mid_characters[2][20] =
{ { '\n', '\t', '\r', ' ', '/', ':', '\'', '\"', '\\', '[', ']', '{', '}', '|', '(', ')', '@', '%', ',', 0}, /* KEY_TABLE */
{ '\n', '\t', '\r', '/', ':', '@', '\\', '*', '?', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }; /* QSUB_TABLE */
static const char* keyword[] = { "NONE", "ALL", "TEMPLATE", NULL };
static const char* keyword_strings[4];
static int initialized = 0;
char forbidden_char;
const char* forbidden_string;
int i;
table = table -1;
if (!initialized) {
begin_strings[0][0] = MSG_GDI_KEYSTR_DOT;
begin_strings[0][1] = MSG_GDI_KEYSTR_HASH;
begin_strings[0][2] = NULL;
begin_strings[1][0] = NULL;
begin_strings[1][1] = NULL;
begin_strings[1][2] = NULL;
mid_strings[0][0] = MSG_GDI_KEYSTR_RETURN;
mid_strings[0][1] = MSG_GDI_KEYSTR_TABULATOR;
mid_strings[0][2] = MSG_GDI_KEYSTR_CARRIAGERET;
mid_strings[0][3] = MSG_GDI_KEYSTR_SPACE;
mid_strings[0][4] = MSG_GDI_KEYSTR_SLASH;
mid_strings[0][5] = MSG_GDI_KEYSTR_COLON;
mid_strings[0][6] = MSG_GDI_KEYSTR_QUOTE;
mid_strings[0][7] = MSG_GDI_KEYSTR_DBLQUOTE;
mid_strings[0][8] = MSG_GDI_KEYSTR_BACKSLASH;
mid_strings[0][9] = MSG_GDI_KEYSTR_BRACKETS;
mid_strings[0][10] = MSG_GDI_KEYSTR_BRACKETS;
mid_strings[0][11] = MSG_GDI_KEYSTR_BRACES;
mid_strings[0][12] = MSG_GDI_KEYSTR_BRACES;
mid_strings[0][13] = MSG_GDI_KEYSTR_PIPE;
mid_strings[0][14] = MSG_GDI_KEYSTR_PARENTHESIS;
mid_strings[0][15] = MSG_GDI_KEYSTR_PARENTHESIS;
mid_strings[0][16] = MSG_GDI_KEYSTR_AT;
mid_strings[0][17] = MSG_GDI_KEYSTR_PERCENT;
mid_strings[0][18] = MSG_GDI_KEYSTR_COMMA;
mid_strings[0][19] = NULL;
mid_strings[1][0] = MSG_GDI_KEYSTR_RETURN;
mid_strings[1][1] = MSG_GDI_KEYSTR_TABULATOR;
mid_strings[1][2] = MSG_GDI_KEYSTR_CARRIAGERET;
mid_strings[1][3] = MSG_GDI_KEYSTR_SLASH;
mid_strings[1][4] = MSG_GDI_KEYSTR_COLON;
mid_strings[1][5] = MSG_GDI_KEYSTR_AT;
mid_strings[1][6] = MSG_GDI_KEYSTR_BACKSLASH;
mid_strings[1][7] = MSG_GDI_KEYSTR_ASTERISK;
mid_strings[1][8] = MSG_GDI_KEYSTR_QUESTIONMARK;
mid_strings[1][9] = NULL;
keyword_strings[0] = MSG_GDI_KEYSTR_KEYWORD;
keyword_strings[1] = MSG_GDI_KEYSTR_KEYWORD;
keyword_strings[2] = MSG_GDI_KEYSTR_KEYWORD;
keyword_strings[3] = NULL;
initialized = 1;
}
if (str == NULL) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_NULL_S, name));
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
/* check string length first, if too long -> error */
if (strlen(str) > str_length) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_LENGTH_U, sge_u32c(str_length)));
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
/* check first character */
i = -1;
while ((forbidden_char = begin_chars[table][++i])) {
if (str[0] == forbidden_char) {
if (isprint((int) forbidden_char)) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_FIRSTCHAR_SC,
begin_strings[table][i], begin_chars[table][i]));
} else {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_FIRSTCHAR_S,
begin_strings[table][i]));
}
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
}
/* check all characters in str */
i = -1;
while ((forbidden_char = mid_characters[table][++i])) {
if (strchr(str, forbidden_char)) {
if (isprint((int) forbidden_char)) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_MIDCHAR_SC,
mid_strings[table][i], mid_characters[table][i]));
} else {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_MIDCHAR_S,
mid_strings[table][i]));
}
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
}
/* reject invalid keywords */
i = -1;
while ((forbidden_string = keyword[++i])) {
if (!strcasecmp(str, forbidden_string)) {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_GDI_KEYSTR_KEYWORD_SS,
keyword_strings[i],
forbidden_string));
answer_list_add(alpp, SGE_EVENT, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR);
return STATUS_EUNKNOWN;
}
}
return STATUS_OK;
}
static bool
hgroup_mod_hostlist(lListElem *hgroup, lList **answer_list,
lListElem *reduced_elem, int sub_command,
lList **add_hosts, lList **rem_hosts,
lList **occupant_groups)
{
bool ret = true;
DENTER(TOP_LAYER, "hgroup_mod_hostlist");
if (hgroup != NULL && reduced_elem != NULL) {
int pos = lGetPosViaElem(reduced_elem, HGRP_host_list, SGE_NO_ABORT);
if (pos >= 0) {
lList *list = lGetPosList(reduced_elem, pos);
lList *old_href_list = lCopyList("", lGetList(hgroup, HGRP_host_list));
lList *master_list = *(hgroup_list_get_master_list());
lList *href_list = NULL;
lList *add_groups = NULL;
lList *rem_groups = NULL;
if (ret) {
ret &= href_list_resolve_hostnames(list, answer_list, true);
}
if (ret) {
attr_mod_sub_list(answer_list, hgroup, HGRP_host_list, HR_name,
reduced_elem, sub_command, SGE_ATTR_HOSTLIST,
SGE_OBJ_HGROUP, 0);
href_list = lGetList(hgroup, HGRP_host_list);
}
if (ret) {
ret &= href_list_find_diff(href_list, answer_list, old_href_list,
add_hosts, rem_hosts, &add_groups,
&rem_groups);
}
if (ret && add_groups != NULL) {
ret &= hgroup_list_exists(master_list, answer_list, add_groups);
}
if (ret) {
ret &= href_list_find_effective_diff(answer_list, add_groups,
rem_groups, master_list,
add_hosts, rem_hosts);
}
if (ret) {
ret &= href_list_resolve_hostnames(*add_hosts, answer_list, false);
}
/*
* Try to find cycles in the definition
*/
if (ret) {
ret &= hgroup_find_all_referencees(hgroup, answer_list,
master_list, occupant_groups);
ret &= href_list_add(occupant_groups, answer_list,
lGetHost(hgroup, HGRP_name));
if (ret) {
if (*occupant_groups != NULL && add_groups != NULL) {
lListElem *add_group = NULL;
for_each(add_group, add_groups) {
const char *name = lGetHost(add_group, HR_name);
if (href_list_has_member(*occupant_groups, name)) {
break;
}
}
if (add_group == NULL) {
/*
* No cycle found => success
*/
;
} else {
SGE_ADD_MSG_ID(sprintf(SGE_EVENT, MSG_HGROUP_CYCLEINDEF_SS,
lGetHost(add_group, HR_name),
lGetHost(hgroup, HGRP_name)));
answer_list_add(answer_list, SGE_EVENT, STATUS_ESYNTAX,
ANSWER_QUALITY_ERROR);
ret = false;
}
}
}
}
/* - -- -- -- -- -- -- -- -- -- -- -- -- -- -
user_args - a cull list(UE_Type) of users
acl_args - a cull list(US_Type) of acl
returns
0 on success
-1 on error
*/
int sge_client_add_user(
sge_gdi_ctx_class_t *ctx,
lList **alpp,
lList *user_args,
lList *acl_args
) {
lListElem *userarg, *aclarg;
lList *acl=NULL, *answers=NULL;
const char *acl_name, *user_name;
lCondition *where;
lEnumeration *what;
u_long32 status;
int already;
DENTER(TOP_LAYER, "sge_client_add_user");
what = lWhat("%T(ALL)", US_Type);
for_each(aclarg,acl_args) {
acl_name = lGetString(aclarg, US_name);
where = lWhere("%T(%I==%s)", US_Type, US_name, acl_name);
for_each(userarg, user_args) {
already = 0;
user_name=lGetString(userarg, UE_name);
/* get old acl */
answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_GET, &acl, where, what, false);
lFreeList(&answers);
if (acl && lGetNumberOfElem(acl) > 0) {
if (!lGetSubStr(lFirst(acl), UE_name, user_name, US_entries)) {
lAddSubStr(lFirst(acl), UE_name, user_name, US_entries, UE_Type);
/* mod the acl */
answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_MOD, &acl,
NULL, NULL, false);
} else {
already = 1;
}
} else {
/* build new list */
lAddElemStr(&acl, US_name, acl_name, US_Type);
lAddSubStr(lFirst(acl), UE_name, user_name, US_entries, UE_Type);
/* add the acl */
answers = ctx->gdi(ctx, SGE_US_LIST, SGE_GDI_ADD, &acl,
NULL, NULL, false);
}
if (already) {
status = STATUS_EEXIST;
SGE_ADD_MSG_ID( sprintf(SGE_EVENT, MSG_GDI_USERINACL_SS, user_name, acl_name));
}
else {
if ((status = lGetUlong(lFirst(answers), AN_status))!=STATUS_OK) {
const char *cp;
cp = lGetString(lFirst(answers), AN_text);
if (cp) {
sprintf(SGE_EVENT, "%s", cp);
}
else {
SGE_ADD_MSG_ID( sprintf(SGE_EVENT, MSG_GDI_CANTADDTOACL_SS, user_name, acl_name));
}
} else {
sprintf(SGE_EVENT, MSG_GDI_ADDTOACL_SS, user_name, acl_name);
}
lFreeList(&answers);
}
answer_list_add(alpp, SGE_EVENT, status,
((status == STATUS_OK) ? ANSWER_QUALITY_INFO : ANSWER_QUALITY_ERROR));
lFreeList(&acl);
}