static bool sge_gdi_map_pack_errors(int pack_ret, lList **answer_list) { bool ret = true; DENTER(GDI_LAYER, "sge_gdi_map_pack_errors"); switch (pack_ret) { case PACK_SUCCESS: break; case PACK_ENOMEM: answer_list_add_sprintf(answer_list, STATUS_ERROR2, ANSWER_QUALITY_ERROR, MSG_GDI_MEMORY_NOTENOUGHMEMORYFORPACKINGGDIREQUEST); break; case PACK_FORMAT: answer_list_add_sprintf(answer_list, STATUS_ERROR3, ANSWER_QUALITY_ERROR, MSG_GDI_REQUESTFORMATERROR); break; default: answer_list_add_sprintf(answer_list, STATUS_ERROR1, ANSWER_QUALITY_ERROR, MSG_GDI_UNEXPECTEDERRORWHILEPACKINGGDIREQUEST); break; } ret = (pack_ret == PACK_SUCCESS) ? true : false; DRETURN(ret); }
bool spool_set_option(lList **answer_list, lListElem *context, const char *option) { bool ret = true; DENTER(TOP_LAYER, "spool_set_option"); PROF_START_MEASUREMENT(SGE_PROF_SPOOLING); if (context == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_NOVALIDCONTEXT_S, SGE_FUNC); } else { lListElem *rule; for_each (rule, lGetList(context, SPC_rules)) { spooling_option_func func = (spooling_option_func) lGetRef(rule, SPR_option_func); if (func != NULL) { if (!func(answer_list, rule, option)) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_SETOPTIONOFRULEFAILED_SS, lGetString(rule, SPR_name), lGetString(context, SPC_name)); ret = false; break; } } } }
char *qmonReadText(const char *filename, lList **alpp) { char *text = NULL; SGE_STRUCT_STAT statb; FILE *fp = NULL; DENTER(GUI_LAYER, "qmonReadText"); if (filename == NULL) { answer_list_add_sprintf(alpp, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, "No filename specified"); DRETURN(NULL); } /* ** make sure the file is a regular text file and open it */ if (SGE_STAT(filename, &statb) == -1 || (statb.st_mode & S_IFMT) != S_IFREG || !(fp = fopen(filename, "r"))) { answer_list_add_sprintf(alpp, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_FILE_OPENFAILED_S, filename); DRETURN(NULL); } /* ** put the contents of the file in the Text widget by allocating ** enough space for the entire file, reading the file into the ** allocated space, and using XmTextFieldSetString() to show the file. */ if ((text = XtMalloc((unsigned)(statb.st_size + 1))) == NULL) { answer_list_add_sprintf(alpp, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, "%s", MSG_MEMORY_MALLOCFAILED); FCLOSE(fp); DRETURN(NULL); } if (!fread(text, sizeof (char), statb.st_size + 1, fp)) { answer_list_add_sprintf(alpp, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_FILE_FREADFAILED_SS, filename, strerror(errno)); } text[statb.st_size] = 0; /* be sure to NULL-terminate */ FCLOSE(fp); DRETURN(text); FCLOSE_ERROR: XtFree(text); answer_list_add_sprintf(alpp, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_FILE_NOCLOSE_SS, filename, strerror(errno)); DRETURN(NULL); }
static bool sge_parse_from_file_qrstat(const char *file, lList **ppcmdline, lList **alpp) { bool ret = true; DENTER(TOP_LAYER, "sge_parse_from_file_qrstat"); if (ppcmdline == NULL) { ret = false; } else { if (!sge_is_file(file)) { /* * This is no error */ DPRINTF(("file "SFQ" does not exist\n", file)); } else { char *file_as_string = NULL; int file_as_string_length; file_as_string = sge_file2string(file, &file_as_string_length); if (file_as_string == NULL) { answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_ANSWER_ERRORREADINGFROMFILEX_S, file); ret = false; } else { char **token = NULL; token = stra_from_str(file_as_string, " \n\t"); *alpp = cull_parse_cmdline(QRSTAT, token, environ, ppcmdline, FLG_USE_PSEUDOS); } } } DRETURN(ret); }
/****** sge_cqueue_verify/cqueue_verify_memory_value() **************************** * NAME * cqueue_verify_memory_value() -- verify a queue memory attribute like h_vmem * * SYNOPSIS * bool * cqueue_verify_memory_value(lListElem *cqueue, lList **answer_list, * lListElem *attr_elem) * * FUNCTION * Verifies if a memory attribute of a queue is in the expected range * (0 .. INFINITY) NONE is no allowed value. * * INPUTS * lListElem *cqueue - The queue to verify. * lList **answer_list - answer list to report errors * lListElem *attr_elem - the attribute to verify * * RESULT * bool - true on success, false on error * * NOTES * MT-NOTE: cqueue_verify_memory_value() is MT safe *******************************************************************************/ bool cqueue_verify_memory_value(lListElem *cqueue, lList **answer_list, lListElem *attr_elem) { bool ret = true; DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_memory_value"); if (cqueue != NULL && attr_elem != NULL) { const char *memory_string = lGetString(attr_elem, AMEM_value); #if 1 lListElem *copy = lCopyElem(attr_elem); if (!object_parse_field_from_string(copy, answer_list, AMEM_value, memory_string)) { ret = false; } lFreeElem(©); #else if (memory_string == NULL || !strcasecmp(memory_string, "none")) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_NONE_NOT_ALLOWED_S, "memory values"); ret = false; } #endif } DEXIT; return ret; }
static bool sge_gdi_task_verify(sge_gdi_task_class_t * task, lList **answer_list) { bool ret = true; #if 0 int operation = 0; lList *list = NULL; u_long32 target = 0; #endif DENTER(TOP_LAYER, "sge_gdi_task_verify"); #if 0 operation = SGE_GDI_GET_OPERATION(task->command); list = task->data_list; target = task->target; /* EB: TODO: this check does not work for AR objects why? */ if (!list && !(operation == SGE_GDI_PERMCHECK || operation == SGE_GDI_GET || operation == SGE_GDI_TRIGGER || (operation == SGE_GDI_DEL && target == SGE_STN_LIST)) ) { answer_list_add_sprintf(answer_list, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, MSG_GDI_GDI_VERIFY_REQUEST_FAILED); ret = false; } #endif DRETURN(ret); }
/****** sge_utility/verify_host_name() ***************************************** * NAME * verify_host_name() -- verify a hostname * * SYNOPSIS * bool * verify_host_name(lList **answer_list, const char *host_name) * * FUNCTION * Verifies if a hostname is correct (regarding maximum length etc.). * * INPUTS * lList **answer_list - answer list to pass back error messages * const char *host_name - the hostname to verify * * RESULT * bool - true on success, * false on error with error message in answer_list * * NOTES * MT-NOTE: verify_host_name() is MT safe *******************************************************************************/ bool verify_host_name(lList **answer_list, const char *host_name) { bool ret = true; if (host_name == NULL || *host_name == '\0') { answer_list_add_sprintf(answer_list, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_HOSTNAME_NOT_EMPTY); ret = false; } if (ret) { if (strlen(host_name) > CL_MAXHOSTNAMELEN_LENGTH) { answer_list_add_sprintf(answer_list, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_HOSTNAME_NOT_EMPTY); } } /* TODO: further verification (e.g. character set) */ return ret; }
/*----------------------------------------------------------- * Error * print simple error message *-----------------------------------------------------------*/ static int Error(s_token *token_p, int expected) { DENTER(GUI_LAYER, "sge_eval_expression:Error"); if (token_p->tt!=T_ERROR){ answer_list_add_sprintf(token_p->answer_list, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_EVAL_EXPRESSION_PARSE_ERROR, token_p->s - token_p->expr , token_p->expr); ERROR((SGE_EVENT, MSG_EVAL_EXPRESSION_PARSE_ERROR, (int)(token_p->s - token_p->expr) , token_p->expr)); token_p->et=expected; token_p->tt=T_ERROR; } DRETURN((-1)); /*negative return value is error index */ }
/****** gdi/request_internal/sge_gdi_packet_create_base() ******************** * NAME * sge_gdi_packet_create_base() -- ??? * * SYNOPSIS * sge_gdi_packet_class_t * * sge_gdi_packet_create_base(lList **answer_list) * * FUNCTION * Creates a new GDI packet and initializes all base structure memebers * where necessary information is available. * * "uid", "gid", "user" and "group" memebers part of sge_gdi_packet_class_t * will not be initialized with this function. Instead * sge_gdi_packet_create() can be used or the function * sge_gdi_packet_initialize_auth_info() can be called afterwards. * * INPUTS * lList **answer_list - answer list in case of error * * RESULT * sge_gdi_packet_class_t * - new GDI packet * * NOTES * MT-NOTE: sge_gdi_packet_create_base() is MT safe * * SEE ALSO * gdi/request_internal/sge_gdi_packet_create() * gdi/request_internal/sge_gdi_packet_initialize_auth_info() ******************************************************************************/ sge_gdi_packet_class_t * sge_gdi_packet_create_base(lList **answer_list) { sge_gdi_packet_class_t *ret = NULL; DENTER(TOP_LAYER, "sge_gdi_packet_create_base"); ret = (sge_gdi_packet_class_t *) sge_malloc(sizeof(sge_gdi_packet_class_t)); if (ret != NULL) { int local_ret1; int local_ret2; local_ret1 = pthread_mutex_init(&(ret->mutex), NULL); local_ret2 = pthread_cond_init(&(ret->cond), NULL); if (local_ret1 == 0 && local_ret2 == 0) { ret->is_intern_request = false; ret->is_gdi_request = true; ret->is_handled = false; ret->id = 0; ret->host = NULL; ret->commproc = NULL; ret->commproc_id = 0; ret->version = GRM_GDI_VERSION; ret->first_task = NULL; ret->last_task = NULL; ret->auth_info = NULL; ret->next = NULL; memset(&(ret->pb), 0, sizeof(sge_pack_buffer)); } else { answer_list_add_sprintf(answer_list, STATUS_EMALLOC, ANSWER_QUALITY_ERROR, MSG_MEMORY_MALLOCFAILED); } } else { answer_list_add_sprintf(answer_list, STATUS_EMALLOC, ANSWER_QUALITY_ERROR, MSG_SGETEXT_NOMEM); } DRETURN(ret); }
bool binding_parse_from_string(lListElem *this_elem, lList **answer_list, dstring *string) { bool ret = true; DENTER(BINDING_LAYER, "binding_parse_from_string"); if (this_elem != NULL && string != NULL) { int amount = 0; int stepsize = 0; int firstsocket = 0; int firstcore = 0; binding_type_t type = BINDING_TYPE_NONE; dstring strategy = DSTRING_INIT; dstring socketcorelist = DSTRING_INIT; dstring error = DSTRING_INIT; if (parse_binding_parameter_string(sge_dstring_get_string(string), &type, &strategy, &amount, &stepsize, &firstsocket, &firstcore, &socketcorelist, &error) != true) { dstring parse_binding_error = DSTRING_INIT; sge_dstring_append_dstring(&parse_binding_error, &error); answer_list_add_sprintf(answer_list, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, MSG_PARSE_XOPTIONWRONGARGUMENT_SS, "-binding", sge_dstring_get_string(&parse_binding_error)); sge_dstring_free(&parse_binding_error); ret = false; } else { lSetString(this_elem, BN_strategy, sge_dstring_get_string(&strategy)); lSetUlong(this_elem, BN_type, type); lSetUlong(this_elem, BN_parameter_socket_offset, (firstsocket >= 0) ? firstsocket : 0); lSetUlong(this_elem, BN_parameter_core_offset, (firstcore >= 0) ? firstcore : 0); lSetUlong(this_elem, BN_parameter_n, (amount >= 0) ? amount : 0); lSetUlong(this_elem, BN_parameter_striding_step_size, (stepsize >= 0) ? stepsize : 0); if (strstr(sge_dstring_get_string(&strategy), "explicit") != NULL) { lSetString(this_elem, BN_parameter_explicit, sge_dstring_get_string(&socketcorelist)); } } sge_dstring_free(&strategy); sge_dstring_free(&socketcorelist); sge_dstring_free(&error); } DRETURN(ret); }
/** * @brief remove potentially dangerous environment variables * * The function removes potentially dangerous environment variables from * an environment list (e.g. from job or pe task submission). * The following variables are removed: * - LD_PRELOAD * - all flavours of LD_LIBRARY_PATH, SHLIB_PATH etc. * unless qmaster param ENABLE_SUBMIT_LIB_PATH is set to TRUE * We generate an INFO message to be output by the submit client. * * @param env_list the environment list * @param answer_list answer_list to report removal of variables */ void var_list_filter_env_list(lList *env_list, lList **answer_list) { lListElem *ep; /* LD_PRELOAD */ ep = lGetElemStr(env_list, VA_variable, "LD_PRELOAD"); if (ep != NULL) { lRemoveElem(env_list, &ep); answer_list_add_sprintf(answer_list, STATUS_ESYNTAX, ANSWER_QUALITY_INFO, MSG_REMOVED_ENV_VAR_S, "LD_PRELOAD"); } /* other potentially dangerous variables */ if (!mconf_get_enable_submit_lib_path()) { static const char *lib_path_names[] = { "LD_LIBRARY_PATH", "LD_LIBRARY_PATH_32", "LD_LIBRARY_PATH_64", "LIBPATH", "SHLIB_PATH", "DYLD_LIBRARY_PATH", "LD_ORIGIN_PATH", "LD_CONFIG", NULL }; const char *var_name; int i; for (i = 0; (var_name = lib_path_names[i]) != NULL; i++) { ep = lGetElemStr(env_list, VA_variable, var_name); if (ep != NULL) { lRemoveElem(env_list, &ep); answer_list_add_sprintf(answer_list, STATUS_ESYNTAX, ANSWER_QUALITY_INFO, MSG_REMOVED_ENV_VAR_S, var_name); } } } }
/****** spool/spool_free_context() ************************************** * NAME * spool_free_context() -- free resources of a spooling context * * SYNOPSIS * lListElem* * spool_free_context(lList **answer_list, lListElem *context) * * FUNCTION * Performs a shutdown of the spooling context and releases * all allocated resources. * * INPUTS * lList **answer_list - to return error messages * lListElem *context - the context to free * * RESULT * lListElem* - NULL * * EXAMPLE * lListElem *context; * ... * context = spool_free_context(answer_list, context); * * SEE ALSO * spool/--Spooling * spool/spool_create_context() * spool/spool_shutdown_context() *******************************************************************************/ lListElem * spool_free_context(lList **answer_list, lListElem *context) { DENTER(TOP_LAYER, "spool_free_context"); PROF_START_MEASUREMENT(SGE_PROF_SPOOLING); if (context == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_NOVALIDCONTEXT_S, SGE_FUNC); } else { spool_shutdown_context(answer_list, context); lFreeElem(&context); } PROF_STOP_MEASUREMENT(SGE_PROF_SPOOLING); DRETURN(context); }
/****** spool/spool_create_context() ************************************ * NAME * spool_create_context() -- create a new spooing context * * SYNOPSIS * lListElem * * spool_create_context(lList **answer_list, const char *name); * * FUNCTION * Create a new spooling context. * * INPUTS * lList **answer_list - to return error messages * const char *name - name of the context * * RESULT * lListElem* - the new spooling context * * EXAMPLE * lListElem *context; * * context = spool_create_context(answer_list, "my spooling context"); * ... * * * NOTES * Usually, a service function creating a spooling context * for a certain storage system will be called, e.g. * spool_classic_create_context(). * * SEE ALSO * spool/--Spooling * spool/spool_free_context() * spool/classic/spool_classic_create_context() *******************************************************************************/ lListElem * spool_create_context(lList **answer_list, const char *name) { lListElem *ep = NULL; DENTER(TOP_LAYER, "spool_create_context"); PROF_START_MEASUREMENT(SGE_PROF_SPOOLING); if (name == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_CONTEXTNEEDSNAME); } else { ep = lCreateElem(SPC_Type); lSetString(ep, SPC_name, name); } PROF_STOP_MEASUREMENT(SGE_PROF_SPOOLING); DRETURN(ep); }
/****** sge_cqueue_verify/cqueue_verify_time_value() **************************** * NAME * cqueue_verify_time_value() -- verify a queue time attribute like h_cpu * * SYNOPSIS * bool * cqueue_verify_time_value(lListElem *cqueue, lList **answer_list, * lListElem *attr_elem) * * FUNCTION * Verifies if a time attribute of a queue is in the expected range * (0:0:0 .. INFINITY) NONE is no allowed value. * * INPUTS * lListElem *cqueue - The queue to verify. * lList **answer_list - answer list to report errors * lListElem *attr_elem - the attribute to verify * * RESULT * bool - true on success, false on error * * NOTES * MT-NOTE: cqueue_verify_time_value() is MT safe *******************************************************************************/ bool cqueue_verify_time_value(lListElem *cqueue, lList **answer_list, lListElem *attr_elem) { bool ret = true; DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_time_value"); if (cqueue != NULL && attr_elem != NULL) { const char *time_string = lGetString(attr_elem, ATIME_value); if (time_string == NULL || !strcasecmp(time_string, "none")) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_NONE_NOT_ALLOWED_S, "time values"); ret = false; } } DEXIT; return ret; }
/****** sge_cqueue_verify/cqueue_verify_job_slots() **************************** * NAME * cqueue_verify_job_slots() -- verify the queue slots attribute * * SYNOPSIS * bool * cqueue_verify_job_slots(lListElem *cqueue, lList **answer_list, * lListElem *attr_elem) * * FUNCTION * Verifies if the slots attribute of a queue is in the expected range * (0 .. MAX_SEQNUM). MAX_SEQNUM is 9999999. * * INPUTS * lListElem *cqueue - The queue to verify. * lList **answer_list - answer list to report errors * lListElem *attr_elem - the attribute to verify * * RESULT * bool - true on success, false on error * * NOTES * MT-NOTE: cqueue_verify_job_slots() is MT safe *******************************************************************************/ bool cqueue_verify_job_slots(lListElem *cqueue, lList **answer_list, lListElem *attr_elem) { bool ret = true; DENTER(CQUEUE_VERIFY_LAYER, "cqueue_verify_job_slots"); if (cqueue != NULL && attr_elem != NULL) { u_long32 slots = lGetUlong(attr_elem, AULNG_value); if (slots > MAX_SEQNUM) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_ATTR_INVALID_ULONGVALUE_USUU, sge_u32c(slots), "slots", sge_u32c(0), sge_u32c(MAX_SEQNUM)); ret = false; } } DEXIT; return ret; }
/****** sge_var/var_list_verify() ********************************************** * NAME * var_list_verify() -- verify contents of a variable list * * SYNOPSIS * bool * var_list_verify(const lList *lp, lList **answer_list) * * FUNCTION * Verifies the contents of a variable list. * Variable names may not be NULL or empty strings. * * INPUTS * const lList *lp - the list to verify * lList **answer_list - answer list to pass back error messages * * RESULT * bool - true on success, * false in case of errors, error message in answer_list * * NOTES * MT-NOTE: var_list_verify() is MT safe *******************************************************************************/ bool var_list_verify(const lList *lp, lList **answer_list) { bool ret = true; lListElem *ep; for_each (ep, lp) { const char *variable = lGetString(ep, VA_variable); if (variable == NULL || variable[0] == '\0') { answer_list_add_sprintf(answer_list, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_OBJECT_VARIABLENAME_NOT_EMPTY); ret = false; break; } } /* TODO: further checks, e.g. length, format strings */ return ret; }
bool switch_list_qstat_parse_from_file(lList **switch_list, lList **answer_list, int mode, const char *file) { bool ret = true; DENTER(TOP_LAYER, "switch_list_qstat_parse_from_file"); if (switch_list == NULL) { ret = false; } else { if (!sge_is_file(file)) { /* * This is no error */ DPRINTF(("file "SFQ" does not exist\n", file)); ret = true; } else { char *file_as_string = NULL; int file_as_string_length; file_as_string = sge_file2string(file, &file_as_string_length); if (file_as_string == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_ANSWER_ERRORREADINGFROMFILEX_S, file); ret = false; } else { char **token = NULL; token = stra_from_str(file_as_string, " \n\t"); ret = switch_list_qstat_parse_from_cmdline(switch_list, answer_list, mode, token); sge_strafree(&token); } sge_free(&file_as_string); } } DRETURN(ret); }
/****** qmaster/ckpt/ckpt_spool() ********************************************* * * NAME * ckpt_spool -- spool a ckpt object * * SYNOPSIS * int ckpt_spool(lList **alpp, lListElem *ep, gdi_object_t *object); * * FUNCTION * This function will be called from the framework which will * add/modify/delete generic gdi objects. * After an object was modified/added successfully it * is necessary to spool the current state to the filesystem. * * * INPUTS * alpp - reference to an answer list. * ep - ckpt object which should be spooled * object - structure of the gdi framework which contains * additional information to perform the request * (function pointers, names, CULL-types) * * RESULT * [alpp] - error messages will be added to this list * 0 - success * STATUS_EEXIST - an error occured ******************************************************************************/ int ckpt_spool(sge_gdi_ctx_class_t *ctx, lList **alpp, lListElem *ep, gdi_object_t *object) { lList *answer_list = NULL; bool dbret; bool job_spooling = ctx->get_job_spooling(ctx); DENTER(TOP_LAYER, "ckpt_spool"); dbret = spool_write_object(&answer_list, spool_get_default_context(), ep, lGetString(ep, CK_name), SGE_TYPE_CKPT, job_spooling); answer_list_output(&answer_list); if (!dbret) { answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_PERSISTENCE_WRITE_FAILED_S, lGetString(ep, CK_name)); } DEXIT; return dbret ? 0 : 1; }
static bool sge_parse_qrstat(sge_gdi_ctx_class_t *ctx, lList **answer_list, qrstat_env_t *qrstat_env, lList **cmdline) { bool ret = true; DENTER(TOP_LAYER, "sge_parse_qrstat"); qrstat_env->is_summary = true; while (lGetNumberOfElem(*cmdline)) { u_long32 value; /* -help */ if (opt_list_has_X(*cmdline, "-help")) { sge_usage(QRSTAT, stdout); DEXIT; SGE_EXIT((void**)&ctx, 0); } /* -u */ while (parse_multi_stringlist(cmdline, "-u", answer_list, &(qrstat_env->user_list), ST_Type, ST_name)) { continue; } /* -explain */ while (parse_flag(cmdline, "-explain", answer_list, &value)) { qrstat_filter_add_core_attributes(qrstat_env); qrstat_filter_add_explain_attributes(qrstat_env); qrstat_env->is_explain = (value > 0) ? true : false; continue; } /* -xml */ while (parse_flag(cmdline, "-xml", answer_list, &value)) { qrstat_filter_add_core_attributes(qrstat_env); qrstat_filter_add_xml_attributes(qrstat_env); qrstat_env->is_xml = (value > 0) ? true : false; continue; } /* -ar */ while (parse_u_longlist(cmdline, "-ar", answer_list, &(qrstat_env->ar_id_list))) { qrstat_filter_add_core_attributes(qrstat_env); qrstat_filter_add_ar_attributes(qrstat_env); qrstat_filter_add_ar_where(qrstat_env); qrstat_env->is_summary = false; continue; } if (lGetNumberOfElem(*cmdline)) { sge_usage(QRSTAT, stdout); answer_list_add(answer_list, MSG_PARSE_TOOMANYOPTIONS, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR); ret = false; break; } } if (qrstat_env->is_summary) { char user[128] = ""; if (sge_uid2user(geteuid(), user, sizeof(user), MAX_NIS_RETRIES)) { answer_list_add_sprintf(answer_list, STATUS_ESEMANTIC, ANSWER_QUALITY_CRITICAL, MSG_SYSTEM_RESOLVEUSER_U, (u_long32)geteuid()); ret = false; } else { str_list_transform_user_list(&(qrstat_env->user_list), answer_list, user); qrstat_filter_add_core_attributes(qrstat_env); qrstat_filter_add_u_where(qrstat_env); } } DRETURN(ret); }
static sge_gdi_task_class_t * sge_gdi_task_create(sge_gdi_packet_class_t * packet, lList **answer_list, u_long32 target, u_long32 command, lList **lp, lList **a_list, lCondition **condition, lEnumeration **enumeration, bool do_copy, bool do_verify) { sge_gdi_task_class_t *task = NULL; DENTER(TOP_LAYER, "sge_gdi_task_create"); task = (sge_gdi_task_class_t *) sge_malloc(sizeof(sge_gdi_task_class_t)); if (task != NULL) { task->id = ((packet->last_task != NULL) ? (packet->last_task->id + 1) : 1); task->command = command; task->target = target; task->next = NULL; task->do_select_pack_simultaneous = false; if (do_copy) { if (enumeration != NULL && *enumeration != NULL) { task->data_list = (((lp != NULL) && (*lp != NULL)) ? lSelect("", *lp, NULL, *enumeration) : NULL); } else { task->data_list = (((lp != NULL) && (*lp != NULL)) ? lCopyList("", *lp) : NULL); } task->answer_list = (((a_list != NULL) && (*a_list != NULL)) ? lCopyList("", *a_list) : NULL); task->condition = (((condition != NULL) && (*condition != NULL)) ? lCopyWhere(*condition) : NULL); task->enumeration = (((enumeration != NULL) && (*enumeration != NULL)) ? lCopyWhat(*enumeration) : NULL); } else { if ((lp != NULL) && (*lp != NULL)) { task->data_list = *lp; *lp = NULL; } else { task->data_list = NULL; } if ((a_list != NULL) && (*a_list != NULL)) { task->answer_list = *a_list; *a_list = NULL; } else { task->answer_list = NULL; } if ((condition != NULL) && (*condition != NULL)) { task->condition = *condition; *condition = NULL; } else { task->condition = NULL; } if ((enumeration != NULL) && (*enumeration != NULL)) { task->enumeration = *enumeration; *enumeration = NULL; } else { task->enumeration = NULL; } } if (do_verify && !sge_gdi_task_verify(task, answer_list)) { if (do_copy == true) { lFreeList(&(task->data_list)); lFreeList(&(task->answer_list)); lFreeWhere(&(task->condition)); lFreeWhat(&(task->enumeration)); } else { task->data_list = NULL; task->answer_list = NULL; task->condition = NULL; task->enumeration = NULL; } sge_gdi_task_free(&task); } } else { answer_list_add_sprintf(answer_list, STATUS_EMALLOC, ANSWER_QUALITY_ERROR, MSG_MEMORY_MALLOCFAILED); } DRETURN(task); }
/****** spool/spool_create_dynamic_context() ********************* * NAME * spool_create_dynamic_context() -- create a spooling context * * SYNOPSIS * lListElem * * spool_create_dynamic_context(lList **answer_list, * const char *shlib_name, const char *args) * * FUNCTION * Create a spooling context. * Which spooling context to use can either be defined at compile time, e.g. * by calling "aimk -spool-classic" or "aimk -spool-flatfile". * * Or dynamic loading of a spooling framework is activated (by building * with "aimk -spool-dynamic". * In this case a shared library is dynamically loaded and the spooling * framework implementation of that shared library is used. * * INPUTS * lList **answer_list - to return error messages * const char *shlib_name - name of a shared lib * const char *args - arguments to be passed to the initialization * function in the specified shared lib. * * RESULT * lListElem * - on success a spooling context, else NULL. * * SEE ALSO * spool/--Spooling *******************************************************************************/ lListElem * spool_create_dynamic_context(lList **answer_list, const char *method, const char *shlib_name, const char *args) { const char *compiled_method; lListElem *context = NULL; DENTER(TOP_LAYER, "spool_create_dynamic_context"); #ifdef SPOOLING_berkeleydb compiled_method = "berkeleydb"; if (strcmp(method, compiled_method) != 0) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_COMPILEDMETHODNECONFIGURED_SS, compiled_method, method); } else { context = spool_berkeleydb_create_context(answer_list, args); } #endif #ifdef SPOOLING_classic compiled_method = "classic"; if (strcmp(method, compiled_method) != 0) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_COMPILEDMETHODNECONFIGURED_SS, compiled_method, method); } else { context = spool_classic_create_context(answer_list, args); } #endif #ifdef SPOOLING_flatfile compiled_method = "flatfile"; if (strcmp(method, compiled_method) != 0) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_COMPILEDMETHODNECONFIGURED_SS, compiled_method, method); } else { context = spool_flatfile_create_context(answer_list, args); } #endif #ifdef SPOOLING_postgres compiled_method = "postgres"; if (strcmp(method, compiled_method) != 0) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_COMPILEDMETHODNECONFIGURED_SS, compiled_method, method); } else { context = spool_postgres_create_context(answer_list, args); } #endif #ifdef SPOOLING_dynamic /* * don't need compiled_method here, but otherwise we get an * unused variable compiler warning. And we need the DPRINTF * on irix6, otherwise we get a set but not used warning. */ compiled_method = "dynamic"; DPRINTF(("creating "SFQ" spooling context\n", compiled_method)); context = spool_dynamic_create_context(answer_list, method, shlib_name, args); #endif if (context == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_ERRORCREATINGCONTEXT_S, method); } DEXIT; return context; }
/****** spool/utilities/spool_default_validate_func() **************** * NAME * spool_default_validate_func() -- validate objects * * SYNOPSIS * bool * spool_default_validate_func(lList **answer_list, * const lListElem *type, * const lListElem *rule, * const lListElem *object, * const char *key, * const sge_object_type object_type) * * FUNCTION * Verifies an object. * * INPUTS * lList **answer_list - to return error messages * const lListElem *type - object type description * const lListElem *rule - rule to use * const lListElem *object - object to validate * const sge_object_type object_type - object type * * RESULT * bool - true on success, else false * * NOTES * This function should not be called directly, it is called by the * spooling framework. * * SEE ALSO *******************************************************************************/ bool spool_default_validate_func(lList **answer_list, const lListElem *type, const lListElem *rule, lListElem *object, const sge_object_type object_type) { bool ret = true; DENTER(TOP_LAYER, "spool_default_validate_func"); switch(object_type) { case SGE_TYPE_ADMINHOST: case SGE_TYPE_EXECHOST: case SGE_TYPE_SUBMITHOST: { int cl_ret; int key_nm = object_type_get_key_nm(object_type); char *old_name = strdup(lGetHost(object, key_nm)); /* try hostname resolving */ if (strcmp(old_name, SGE_GLOBAL_NAME) != 0) { cl_ret = sge_resolve_host(object, key_nm); /* if hostname resolving failed: create error */ if (cl_ret != CL_RETVAL_OK) { if (cl_ret != CL_RETVAL_GETHOSTNAME_ERROR) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_CANTRESOLVEHOSTNAME_SS, old_name, cl_get_error_text(ret)); ret = false; } else { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_WARNING, MSG_SPOOL_CANTRESOLVEHOSTNAME_SS, old_name, cl_get_error_text(ret)); } } else { /* if hostname resolving changed hostname: spool */ const char *new_name; new_name = lGetHost(object, key_nm); if (strcmp(old_name, new_name) != 0) { spooling_write_func write_func = (spooling_write_func)lGetRef(rule, SPR_write_func); spooling_delete_func delete_func = (spooling_delete_func)lGetRef(rule, SPR_delete_func); write_func(answer_list, type, rule, object, new_name, object_type); delete_func(answer_list, type, rule, old_name, object_type); } } } sge_free(&old_name); if (object_type == SGE_TYPE_EXECHOST && ret) { lListElem *load_value; lList *master_centry_list = *object_type_get_master_list(SGE_TYPE_CENTRY); /* all spooled load values are static, therefore we tag them here */ for_each(load_value, lGetList(object, EH_load_list)) { lSetBool(load_value, HL_static, true); } /* necessary to init double values of consumable configuration */ centry_list_fill_request(lGetList(object, EH_consumable_config_list), NULL, master_centry_list, true, false, true); /* necessary to setup actual list of exechost */ debit_host_consumable(NULL, object, master_centry_list, 0, true, NULL); if (ensure_attrib_available(NULL, object, EH_consumable_config_list)) { ret = false; } } }
static spooling_field * _spool_get_fields_to_spool(lList **answer_list, const lDescr *descr, const spool_instr *instr) { spooling_field *fields; int i, j, size; int strip = 0; DENTER(TOP_LAYER, "_spool_get_fields_to_spool"); /* we don't check descr and instr, as we know they are ok * (it's a static function) */ /* count fields to spool */ for (i = 0, size = 0; mt_get_type(descr[i].mt) != lEndT; i++) { if ((descr[i].mt & instr->selection) != 0) { size++; } } /* allocate memory */ fields = (spooling_field *)malloc((size + 1) * sizeof(spooling_field)); if (fields == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_UNABLETOALLOCATEBYTES_DS, (size * 1) * sizeof(spooling_field), SGE_FUNC); DRETURN(NULL); } /* initialize fields */ for (i = 0; i < size; i++) { fields[i].nm = NoName; fields[i].width = 0; fields[i].name = NULL; fields[i].sub_fields = NULL; fields[i].clientdata = NULL; fields[i].read_func = NULL; fields[i].write_func = NULL; } /* do we have to strip field prefixes, e.g. "QU_" from field names? */ if (instr->copy_field_names && instr->strip_field_prefix) { dstring buffer = DSTRING_INIT; const char *prefix = object_get_name_prefix(descr, &buffer); strip = sge_strlen(prefix); sge_dstring_free(&buffer); } /* copy field info */ for (i = 0, j = 0; mt_get_type(descr[i].mt) != lEndT; i++) { if ((descr[i].mt & instr->selection) != 0) { spooling_field *sub_fields = NULL; DPRINTF(("field "SFQ" will be spooled\n", lNm2Str(descr[i].nm))); fields[j].nm = descr[i].nm; if (instr->copy_field_names) { const char *name; name = lNm2Str(descr[i].nm); if(name == NULL || strlen(name) <= strip) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_NONAMEFORATTRIBUTE_D, descr[i].nm); fields = spool_free_spooling_fields(fields); DEXIT; return NULL; } fields[j].name = strdup(name + strip); } if (mt_get_type(descr[i].mt) == lListT) { const lDescr *sub_descr; if (instr->sub_instr == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_DONTKNOWHOWTOSPOOLSUBLIST_SS, lNm2Str(descr[i].nm), SGE_FUNC); fields = spool_free_spooling_fields(fields); DEXIT; return NULL; } sub_descr = object_get_subtype(descr[i].nm); if (sub_descr == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_UNKNOWNOBJECTTYPEFOR_SS, lNm2Str(descr[i].nm), SGE_FUNC); fields = spool_free_spooling_fields(fields); DEXIT; return NULL; } /* recursive spooling, e.g. sharetree */ if (instr->sub_instr == instr && descr == sub_descr) { sub_fields = fields; DPRINTF(("recursive structure detected for field %s\n", lNm2Str(descr[i].nm))); } else { sub_fields = _spool_get_fields_to_spool(answer_list, sub_descr, instr->sub_instr); } } fields[j++].sub_fields = sub_fields; } } /* end of field array */ fields[j].nm = NoName; DEXIT; return fields; }
bool sge_parse_qrsub(sge_gdi_ctx_class_t *ctx, lList *pcmdline, lList **alpp, lListElem **ar) { lListElem *ep = NULL, *next_ep = NULL; lList *lp = NULL; DENTER(TOP_LAYER, "sge_parse_qrsub"); /* -help print this help */ if ((ep = lGetElemStr(pcmdline, SPA_switch, "-help"))) { lRemoveElem(pcmdline, &ep); sge_usage(QRSUB, stdout); DEXIT; SGE_EXIT((void **)&ctx, 0); } /* -a date_time start time in [[CC]YY]MMDDhhmm[.SS] SGE_ULONG */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-a"))) { lSetUlong(*ar, AR_start_time, lGetUlong(ep, SPA_argval_lUlongT)); lRemoveElem(pcmdline, &ep); } /* -e date_time end time in [[CC]YY]MMDDhhmm[.SS] SGE_ULONG*/ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-e"))) { lSetUlong(*ar, AR_end_time, lGetUlong(ep, SPA_argval_lUlongT)); lRemoveElem(pcmdline, &ep); } /* -d time duration in TIME format SGE_ULONG */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-d"))) { lSetUlong(*ar, AR_duration, lGetUlong(ep, SPA_argval_lUlongT)); lRemoveElem(pcmdline, &ep); } /* -w e/v validate availability of AR request, default e SGE_ULONG */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-w"))) { lSetUlong(*ar, AR_verify, lGetInt(ep, SPA_argval_lIntT)); lRemoveElem(pcmdline, &ep); } /* -N name AR name SGE_STRING */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-N"))) { lSetString(*ar, AR_name, lGetString(ep, SPA_argval_lStringT)); lRemoveElem(pcmdline, &ep); } /* -A account_string AR name in accounting record SGE_STRING */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-A"))) { lSetString(*ar, AR_account, lGetString(ep, SPA_argval_lStringT)); lRemoveElem(pcmdline, &ep); } /* -l resource_list request the given resources SGE_LIST */ parse_list_simple(pcmdline, "-l", *ar, AR_resource_list, 0, 0, FLG_LIST_APPEND); centry_list_remove_duplicates(lGetList(*ar, AR_resource_list)); /* -u wc_user access list SGE_LIST */ /* -u ! wc_user TBD: Think about eval_expression support in compare allowed and excluded lists */ parse_list_simple(pcmdline, "-u", *ar, AR_acl_list, ARA_name, 0, FLG_LIST_MERGE); /* -u ! list separation */ lp = lGetList(*ar, AR_acl_list); next_ep = lFirst(lp); while ((ep = next_ep)) { bool is_xacl = false; const char *name = lGetString(ep, ARA_name); next_ep = lNext(ep); if (name[0] == '!') { /* move this element to xacl_list */ is_xacl = true; name++; } if (!is_hgroup_name(name)) { struct passwd *pw; struct passwd pw_struct; char *buffer; int size; stringT group; size = get_pw_buffer_size(); buffer = sge_malloc(size); pw = sge_getpwnam_r(name, &pw_struct, buffer, size); if (pw == NULL) { answer_list_add_sprintf(alpp, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_USER_XISNOKNOWNUSER_S, name); FREE(buffer); DRETURN(false); } sge_gid2group(pw->pw_gid, group, MAX_STRING_SIZE, MAX_NIS_RETRIES); lSetString(ep, ARA_group, group); FREE(buffer); } if (is_xacl) { lListElem *new_ep = lAddSubStr(*ar, ARA_name, name, AR_xacl_list, ARA_Type); lSetString(new_ep, ARA_group, lGetString(ep, ARA_group)); lRemoveElem(lp, &ep); } } /* -q wc_queue_list reserve in queue(s) SGE_LIST */ parse_list_simple(pcmdline, "-q", *ar, AR_queue_list, 0, 0, FLG_LIST_APPEND); /* -pe pe_name slot_range reserve slot range for parallel jobs */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-pe"))) { lSetString(*ar, AR_pe, lGetString(ep, SPA_argval_lStringT)); /* SGE_STRING, */ lSwapList(*ar, AR_pe_range, ep, SPA_argval_lListT); /* SGE_LIST */ lRemoveElem(pcmdline, &ep); } /* AR_master_queue_list -masterq wc_queue_list, SGE_LIST bind master task to queue(s) */ parse_list_simple(pcmdline, "-masterq", *ar, AR_master_queue_list, 0, 0, FLG_LIST_APPEND); /* -ckpt ckpt-name reserve in queue with ckpt method SGE_STRING */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-ckpt"))) { lSetString(*ar, AR_checkpoint_name, lGetString(ep, SPA_argval_lStringT)); lRemoveElem(pcmdline, &ep); } /* -m b/e/a/n define mail notification events SGE_ULONG */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-m"))) { u_long32 ul; u_long32 old_mail_opts; ul = lGetInt(ep, SPA_argval_lIntT); if ((ul & NO_MAIL)) { lSetUlong(*ar, AR_mail_options, 0); } else { old_mail_opts = lGetUlong(*ar, AR_mail_options); lSetUlong(*ar, AR_mail_options, ul | old_mail_opts); } lRemoveElem(pcmdline, &ep); } /* -M user[@host],... notify these e-mail addresses SGE_LIST*/ parse_list_simple(pcmdline, "-M", *ar, AR_mail_list, MR_host, MR_user, FLG_LIST_MERGE); /* -he yes/no hard error handling SGE_ULONG */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-he"))) { lSetUlong(*ar, AR_error_handling, lGetUlong(ep, SPA_argval_lUlongT)); lRemoveElem(pcmdline, &ep); } /* -now reserve in queues with qtype interactive SGE_ULONG */ while ((ep = lGetElemStr(pcmdline, SPA_switch, "-now"))) { u_long32 ar_now = lGetUlong(*ar, AR_type); if(lGetInt(ep, SPA_argval_lIntT)) { JOB_TYPE_SET_IMMEDIATE(ar_now); } else { JOB_TYPE_CLEAR_IMMEDIATE(ar_now); } lSetUlong(*ar, AR_type, ar_now); lRemoveElem(pcmdline, &ep); } /* Remove the script elements. They are not stored in the ar structure */ if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPT))) { lRemoveElem(pcmdline, &ep); } if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPTLEN))) { lRemoveElem(pcmdline, &ep); } if ((ep = lGetElemStr(pcmdline, SPA_switch, STR_PSEUDO_SCRIPTPTR))) { lRemoveElem(pcmdline, &ep); } ep = lFirst(pcmdline); if(ep) { const char *option = lGetString(ep,SPA_switch); /* as jobarg are stored no switch values, need to be filtered */ if(sge_strnullcmp(option, "jobarg") != 0) { answer_list_add_sprintf(alpp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, MSG_PARSE_INVALIDOPTIONARGUMENTX_S, lGetString(ep,SPA_switch)); } else { answer_list_add_sprintf(alpp, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, MSG_PARSE_INVALIDOPTIONARGUMENT); } DRETURN(false); } if (lGetUlong(*ar, AR_start_time) == 0 && lGetUlong(*ar, AR_end_time) != 0 && lGetUlong(*ar, AR_duration) != 0) { lSetUlong(*ar, AR_start_time, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_duration)); } else if (lGetUlong(*ar, AR_start_time) != 0 && lGetUlong(*ar, AR_end_time) == 0 && lGetUlong(*ar, AR_duration) != 0) { lSetUlong(*ar, AR_end_time, duration_add_offset(lGetUlong(*ar, AR_start_time), lGetUlong(*ar, AR_duration))); lSetUlong(*ar, AR_duration, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_start_time)); } else if (lGetUlong(*ar, AR_start_time) != 0 && lGetUlong(*ar, AR_end_time) != 0 && lGetUlong(*ar, AR_duration) == 0) { lSetUlong(*ar, AR_duration, lGetUlong(*ar, AR_end_time) - lGetUlong(*ar, AR_start_time)); } DRETURN(true); }
lList *cull_unparse_job_parameter(sge_gdi_ctx_class_t *ctx, lList **pcmdline, lListElem *job, int flags) { const char *cp; u_long32 ul; lList *answer = NULL; char str[MAX_STRING_SIZE]; lList *lp; int ret; lListElem *ep_opt; const char *username = ctx->get_username(ctx); const char *qualified_hostname = ctx->get_qualified_hostname(ctx); DENTER(TOP_LAYER, "cull_unparse_job_parameter"); /* ** -a ** problem with submission time, but that is not a good ** default option anyway, is not unparsed */ /* ** -A */ if (sge_unparse_account_string(job, pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -c */ if (sge_unparse_checkpoint_option(job, pcmdline, &answer) != 0) { DEXIT; return answer; } /* * -ckpt */ if (sge_unparse_string_option(job, JB_checkpoint_name, "-ckpt", pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -cwd */ if (lGetString(job, JB_cwd)) { ep_opt = sge_add_noarg(pcmdline, cwd_OPT, "-cwd", NULL); } /* * -P */ if (sge_unparse_string_option(job, JB_project, "-P", pcmdline, &answer) != 0) { DEXIT; return answer; } #if 0 /* ** -C */ if (sge_unparse_string_option(job, JB_directive_prefix, "-C", pcmdline, &answer) != 0) { DEXIT; return answer; } #endif /* ** -e */ if (sge_unparse_path_list(job, JB_stderr_path_list, "-e", pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -h, here only user hold supported at the moment */ if ((ul = lGetUlong(lFirst(lGetList(job, JB_ja_tasks)), JAT_hold))) { ep_opt = sge_add_noarg(pcmdline, h_OPT, "-h", NULL); } /* ** -hold_jid */ if ((lp = lGetList(job, JB_jid_request_list))) { int fields[] = { JRE_job_name, 0 }; const char *delis[] = {NULL, ",", NULL}; ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0); if (ret) { DPRINTF(("Error %d formatting jid_request_list as -hold_jid\n", ret)); answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_LIST_ERRORFORMATINGJIDPREDECESSORLISTASHOLDJID); return answer; } ep_opt = sge_add_arg(pcmdline, hold_jid_OPT, lListT, "-hold_jid", str); lSetList(ep_opt, SPA_argval_lListT, lCopyList("hold_jid list", lp)); } /* ** -hold_jid_ad */ if ((lp = lGetList(job, JB_ja_ad_request_list))) { int fields[] = { JRE_job_name, 0 }; const char *delis[] = {NULL, ",", NULL}; ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0); if (ret) { DPRINTF(("Error %d formatting ja_ad_request_list as -hold_jid_ad\n", ret)); answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_LIST_ERRORFORMATINGJIDPREDECESSORLISTASHOLDJIDAD); return answer; } ep_opt = sge_add_arg(pcmdline, hold_jid_ad_OPT, lListT, "-hold_jid_ad", str); lSetList(ep_opt, SPA_argval_lListT, lCopyList("hold_jid_ad list", lp)); } /* ** -i */ if (sge_unparse_path_list(job, JB_stdin_path_list, "-i", pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -j */ if ((ul = lGetBool(job, JB_merge_stderr))) { ep_opt = sge_add_arg(pcmdline, j_OPT, lIntT, "-j", "y"); lSetInt(ep_opt, SPA_argval_lIntT, true); } /* ** -jid */ if ((lp = lGetList(job, JB_job_identifier_list))) { int fields[] = { JRE_job_number, 0}; const char *delis[] = {"", ",", NULL}; ret = uni_print_list(NULL, str, sizeof(str) - 1, lp, fields, delis, 0); if (ret) { DPRINTF(("Error %d formatting job_identifier_list as -jid\n", ret)); answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_LIST_ERRORFORMATINGJOBIDENTIFIERLISTASJID); DRETURN(answer); } ep_opt = sge_add_arg(pcmdline, jid_OPT, lListT, "-jid", str); lSetList(ep_opt, SPA_argval_lListT, lCopyList("jid list", lp)); } /* ** -js */ if ((ul = lGetUlong(job, JB_jobshare)) != 0) { sprintf(str, sge_u32, ul); ep_opt = sge_add_arg(pcmdline, js_OPT, lUlongT, "-js", str); lSetUlong(ep_opt, SPA_argval_lUlongT, ul); } /* ** -lj is in parsing but can't be unparsed here */ /* ** -l */ if (sge_unparse_resource_list(job, JB_hard_resource_list, pcmdline, &answer) != 0) { DEXIT; return answer; } if (sge_unparse_resource_list(job, JB_soft_resource_list, pcmdline, &answer) != 0) { DEXIT; return answer; } /* ** -m */ if ((ul = lGetUlong(job, JB_mail_options))) { cp = sge_unparse_mail_options(ul); if (!cp) { DPRINTF(("Error unparsing mail options\n")); answer_list_add_sprintf(&answer, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_PARSE_ERRORUNPARSINGMAILOPTIONS); return answer; } ep_opt = sge_add_arg(pcmdline, m_OPT, lIntT, "-m", cp); lSetInt(ep_opt, SPA_argval_lIntT, ul); } /* ** -M obviously a problem!!! ** not unparsed at the moment ** does it make sense as a default, after all? */ if ((lp = lGetList(job, JB_mail_list))) { lList *lp_new = NULL; lListElem *ep_new = NULL; lListElem *ep = NULL; const char *host; const char *user; /* ** or rather take all if there are more than one elements? */ for_each(ep, lp) { user = lGetString(ep, MR_user); host = lGetHost(ep, MR_host); if (sge_strnullcmp(user, username) || sge_hostcmp(host, qualified_hostname)) { lp_new = lCreateList("mail list", MR_Type); ep_new = lAddElemStr(&lp_new, MR_user, user, MR_Type); lSetHost(ep_new, MR_host, host); } }
/****** sge_advance_reservation/ar_validate() ********************************** * NAME * ar_validate() -- validate a advance reservation * * SYNOPSIS * bool ar_validate(lListElem *ar, lList **alpp, bool in_master) * * FUNCTION * Ensures a new ar has valid start and end times * * INPUTS * lListElem *ar - the ar to check * lList **alpp - answer list pointer * bool in_master - are we in qmaster? * bool is_spool - do we validate for spooling? * * RESULT * bool - true if OK, else false * * NOTES * MT-NOTE: ar_validate() is MT safe *******************************************************************************/ bool ar_validate(lListElem *ar, lList **alpp, bool in_master, bool is_spool) { u_long32 start_time; u_long32 end_time; u_long32 duration; u_long32 now = sge_get_gmt(); object_description *object_base = object_type_get_object_description(); DENTER(TOP_LAYER, "ar_validate"); /* AR_start_time, SGE_ULONG */ if ((start_time = lGetUlong(ar, AR_start_time)) == 0) { start_time = now; lSetUlong(ar, AR_start_time, start_time); } /* AR_end_time, SGE_ULONG */ end_time = lGetUlong(ar, AR_end_time); duration = lGetUlong(ar, AR_duration); if (end_time == 0 && duration == 0) { answer_list_add_sprintf(alpp, STATUS_EEXIST, ANSWER_QUALITY_ERROR, MSG_AR_MISSING_VALUE_S, "end time or duration"); goto ERROR; } else if (end_time == 0) { end_time = duration_add_offset(start_time, duration); duration = end_time - start_time; lSetUlong(ar, AR_end_time, end_time); lSetUlong(ar, AR_duration, duration); } else if (duration == 0) { duration = end_time - start_time; lSetUlong(ar, AR_duration, duration); } if ((end_time - start_time) != duration) { answer_list_add_sprintf(alpp, STATUS_EEXIST, ANSWER_QUALITY_ERROR, MSG_AR_START_END_DURATION_INVALID); goto ERROR; } if (start_time > end_time) { answer_list_add_sprintf(alpp, STATUS_EEXIST, ANSWER_QUALITY_ERROR, MSG_AR_START_LATER_THAN_END); goto ERROR; } if (!is_spool) { if (start_time < now) { answer_list_add_sprintf(alpp, STATUS_EEXIST, ANSWER_QUALITY_ERROR, MSG_AR_START_IN_PAST); goto ERROR; } } /* AR_owner, SGE_STRING */ if (in_master) { /* AR_name, SGE_STRING */ NULL_OUT_NONE(ar, AR_name); if (object_verify_name(ar, alpp, AR_name, SGE_OBJ_AR)) { goto ERROR; } /* AR_account, SGE_STRING */ NULL_OUT_NONE(ar, AR_account); if (!lGetString(ar, AR_account)) { lSetString(ar, AR_account, DEFAULT_ACCOUNT); } else { if (verify_str_key(alpp, lGetString(ar, AR_account), MAX_VERIFY_STRING, "account string", QSUB_TABLE) != STATUS_OK) { goto ERROR; } } /* AR_verify, SGE_ULONG just verify the reservation or final case */ /* AR_error_handling, SGE_ULONG how to deal with soft and hard exceptions */ /* AR_checkpoint_name, SGE_STRING Named checkpoint */ NULL_OUT_NONE(ar, AR_checkpoint_name); { /* request for non existing ckpt object will be refused */ const char *ckpt_name = NULL; ckpt_name = lGetString(ar, AR_checkpoint_name); if (ckpt_name != NULL) { lList *master_ckpt_list = *object_base[SGE_TYPE_CKPT].list; lListElem *ckpt_ep = ckpt_list_locate(master_ckpt_list, ckpt_name); if (!ckpt_ep) { ERROR((SGE_EVENT, MSG_JOB_CKPTUNKNOWN_S, ckpt_name)); answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR); goto ERROR; } } } /* AR_resource_list, SGE_LIST */ { lList *master_centry_list = *object_base[SGE_TYPE_CENTRY].list; if (centry_list_fill_request(lGetList(ar, AR_resource_list), alpp, master_centry_list, false, true, false)) { goto ERROR; } if (compress_ressources(alpp, lGetList(ar, AR_resource_list), SGE_OBJ_AR)) { goto ERROR; } if (!centry_list_is_correct(lGetList(ar, AR_resource_list), alpp)) { goto ERROR; } } /* AR_queue_list, SGE_LIST */ if (!qref_list_is_valid(lGetList(ar, AR_queue_list), alpp)) { goto ERROR; } /* AR_mail_options, SGE_ULONG */ /* AR_mail_list, SGE_LIST */ /* AR_master_queue_list -masterq wc_queue_list, SGE_LIST bind master task to queue(s) */ if (!qref_list_is_valid(lGetList(ar, AR_master_queue_list), alpp)) { goto ERROR; } /* AR_pe, SGE_STRING, AR_pe_range, SGE_LIST */ NULL_OUT_NONE(ar, AR_pe); { const char *pe_name = NULL; lList *pe_range = NULL; pe_name = lGetString(ar, AR_pe); if (pe_name) { const lListElem *pep; pep = pe_list_find_matching(*object_base[SGE_TYPE_PE].list, pe_name); if (!pep) { ERROR((SGE_EVENT, MSG_JOB_PEUNKNOWN_S, pe_name)); answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR); goto ERROR; } /* check pe_range */ pe_range = lGetList(ar, AR_pe_range); if (object_verify_pe_range(alpp, pe_name, pe_range, SGE_OBJ_AR)!=STATUS_OK) { goto ERROR; } } } /* AR_acl_list, SGE_LIST */ if (userset_list_validate_access(lGetList(ar, AR_acl_list), ARA_name, alpp) != STATUS_OK) { goto ERROR; } /* AR_xacl_list, SGE_LIST */ if (userset_list_validate_access(lGetList(ar, AR_xacl_list), ARA_name, alpp) != STATUS_OK) { goto ERROR; } if (is_spool) { lListElem *jg; dstring cqueue_buffer = DSTRING_INIT; dstring hostname_buffer = DSTRING_INIT; for_each(jg, lGetList(ar, AR_granted_slots)){ const char *hostname = NULL; const char *qname = lGetString(jg, JG_qname); bool has_hostname = false; bool has_domain = false; cqueue_name_split(qname, &cqueue_buffer, &hostname_buffer, &has_hostname, &has_domain); hostname = sge_dstring_get_string(&hostname_buffer); lSetHost(jg, JG_qhostname, hostname); } sge_dstring_free(&cqueue_buffer); sge_dstring_free(&hostname_buffer); } /* AR_type, SGE_ULONG */ /* AR_state, SGE_ULONG state of the AR */ if(lGetUlong(ar, AR_state) == ARL_UNKNOWN){ lSetUlong(ar, AR_state, ARL_CREATION); } } DRETURN(true); ERROR: DRETURN(false); }
/****** sgeobj/sge_eval_expression/sge_eval_expression() ********************** * NAME * sge_eval_expression() -- boolean expression extension * * SYNOPSIS * int sge_eval_expression(u_long32 type, * const char *expr, * const char *value) * * FUNCTION * boolean expression extension of regular expression evaluation function * fnmatch() * * INPUTS * u_long32 type - type of resource * const char *expr - expression string to be evaluated * const char *value - value string to be compared for * lList **answer_list - answer list to pass back error messages * * RESULT * int - result if expression is true or * 0 - strings are the same or both NULL * 1 - if is false * -1 - for empty expression, null, or other error * * SEE ALSO * uti/hostname/sge_hostcmp() * fnmatch() * * NOTES: * MT-NOTE: sge_eval_expression() is MT safe *****************************************************************************/ int sge_eval_expression(u_long32 type, const char *expr, const char *value, lList **answer_list) { int match; char pattern_buf[MAX_STRING_SIZE], value_buf[MAX_STRING_SIZE]; DENTER(BASIS_LAYER, "sge_eval_expression"); /* Null values are supported in str_cmp_null way */ if (expr==NULL && value!=NULL) { DRETURN(-1); } if (expr!=NULL && value==NULL) { DRETURN(1); } if (expr == NULL && value == NULL) { DRETURN(0); } /* To long arguments */ if (strlen(value) >= MAX_STRING_SIZE) { answer_list_add_sprintf(answer_list, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_EVAL_EXPRESSION_LONG_VALUE, MAX_STRING_SIZE); ERROR((SGE_EVENT, MSG_EVAL_EXPRESSION_LONG_VALUE, MAX_STRING_SIZE)); DRETURN(-1); } if (strlen(expr) >= MAX_STRING_SIZE) { answer_list_add_sprintf(answer_list, STATUS_ESYNTAX, ANSWER_QUALITY_ERROR, MSG_EVAL_EXPRESSION_LONG_EXPRESSION, MAX_STRING_SIZE); ERROR((SGE_EVENT, MSG_EVAL_EXPRESSION_LONG_EXPRESSION, MAX_STRING_SIZE)); DRETURN(-1); } { s_token token; /* The main token structure */ token.value=value; /* the copybuffer will be on demand */ token.expr=expr; /* copy per partes to pattern_buf */ token.pattern=pattern_buf; token.s=token.expr; /* Set the index. */ token.tt=T_END; /* Type of token */ token.et=T_EXP; /* Type of expected token */ token.type=type; token.answer_list=answer_list; token.has_patterns = sge_is_expression(token.expr); /* pattern is detected latter */ if(token.has_patterns){ uncaseValue(&token,value_buf); /* Check the value needs to be lowered */ match = OrExpression(&token, false); /* * after the expression has been evaluated * the input stream must be empty * and the token must be T_END */ if (token.tt != T_END) { match=Error(&token, T_END); } else if (token.s[0] != '\0') { /*Something is missing? */ match=Error(&token, token.et); } } else { token.pattern=(char *) token.expr; match = MatchPattern(&token, false); } } DRETURN(match); }
lListElem * spool_dynamic_create_context(lList **answer_list, const char *method, const char *shlib_name, const char *args) { bool ok = true; lListElem *context = NULL; /* shared lib name buffer and handle */ dstring shlib_dstring = DSTRING_INIT; const char *shlib_fullname; void *shlib_handle; /* get_method function pointer and result */ spooling_get_method_func get_spooling_method = NULL; const char *spooling_name = NULL; DENTER(TOP_LAYER, "spool_dynamic_create_context"); /* build the full name of the shared lib - append architecture dependent * shlib postfix */ shlib_fullname = sge_dstring_sprintf(&shlib_dstring, "%s.%s", shlib_name, #if defined(HP11) || defined(HP1164) "sl" #elif defined(DARWIN) "dylib" #else "so" #endif ); #if defined(HP1164) /* ** need to switch to start user for HP */ sge_switch2start_user(); #endif /* open the shared lib */ # if defined(DARWIN) # ifdef RTLD_NODELETE shlib_handle = dlopen(shlib_fullname, RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE); # else shlib_handle = dlopen(shlib_fullname, RTLD_NOW | RTLD_GLOBAL ); # endif /* RTLD_NODELETE */ # else # ifdef RTLD_NODELETE shlib_handle = dlopen(shlib_fullname, RTLD_NOW | RTLD_NODELETE); # else shlib_handle = dlopen(shlib_fullname, RTLD_NOW); # endif /* RTLD_NODELETE */ #endif #if defined(HP1164) /* ** switch back to admin user for HP */ sge_switch2admin_user(); #endif if (shlib_handle == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_ERROROPENINGSHAREDLIB_SS, shlib_fullname, dlerror()); ok = false; } /* retrieve function pointer of get_method function in shared lib */ if (ok) { dstring get_spooling_method_func_name = DSTRING_INIT; sge_dstring_sprintf(&get_spooling_method_func_name, "get_%s_spooling_method", method); get_spooling_method = (spooling_get_method_func) dlsym(shlib_handle, sge_dstring_get_string(&get_spooling_method_func_name)); if (get_spooling_method == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_SHLIBDOESNOTCONTAINSPOOLING_SS, shlib_fullname, dlerror()); ok = false; } sge_dstring_free(&get_spooling_method_func_name); } /* retrieve name of spooling method in shared lib */ if (ok) { spooling_name = get_spooling_method(); if (spooling_name == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_INFO, MSG_SPOOL_SHLIBGETMETHODRETURNSNULL_S, shlib_fullname); ok = false; } else { if (strcmp(spooling_name, method) != 0) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_INFO, MSG_SPOOL_SHLIBCONTAINSXWENEEDY_SSS, shlib_fullname, spooling_name, method); ok = false; } } } /* create spooling context from shared lib */ if (ok) { dstring create_context_func_name = DSTRING_INIT; spooling_create_context_func create_context; answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_INFO, MSG_SPOOL_LOADINGSPOOLINGMETHOD_SS, spooling_name, shlib_fullname); sge_dstring_sprintf(&create_context_func_name, "spool_%s_create_context", spooling_name); create_context = (spooling_create_context_func) dlsym(shlib_handle, sge_dstring_get_string(&create_context_func_name)); if (create_context == NULL) { answer_list_add_sprintf(answer_list, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR, MSG_SPOOL_SHLIBDOESNOTCONTAINSPOOLING_SS, shlib_fullname, dlerror()); ok = false; } else { context = create_context(answer_list, args); } sge_dstring_free(&create_context_func_name); } /* cleanup in case of initialization error */ if (context == NULL) { if (shlib_handle != NULL) { dlclose(shlib_handle); } } sge_dstring_free(&shlib_dstring); DRETURN(context); }