/****** 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); }