/****** libs/sgeobj/ar_get_string_from_event() ********************************
* NAME
* ar_get_string_from_event() -- converts a state event to a string
*
* SYNOPSIS
* const char * ar_get_string_from_event(ar_state_event_t event)
*
* FUNCTION
* Converts a state event id to a human readable string.
*
* INPUTS
* ar_state_event_t event - state event id
*
* RESULT
* const char * - string
*
* NOTES
* MT-NOTE: ar_get_string_from_event() is not MT safe
*******************************************************************************/
const char *
ar_get_string_from_event(ar_state_event_t event)
{
const char *ret = MSG_AR_EVENT_STATE_UNKNOWN;
DENTER(TOP_LAYER, "ar_get_string_from_event");
switch(event) {
case ARL_UNKNOWN:
ret = MSG_AR_EVENT_STATE_UNKNOWN;
break;
case ARL_CREATION:
ret = MSG_AR_EVENT_STATE_CREATION;
break;
case ARL_STARTTIME_REACHED:
ret = MSG_AR_EVENT_STATE_STARTIME_REACHED;
break;
case ARL_ENDTIME_REACHED:
ret = MSG_AR_EVENT_STATE_ENDTIME_REACHED;
break;
case ARL_UNSATISFIED:
ret = MSG_AR_EVENT_STATE_UNSATISFIED;
break;
case ARL_OK:
ret = MSG_AR_EVENT_STATE_OK;
break;
case ARL_TERMINATED:
ret = MSG_AR_EVENT_STATE_TERMINATED;
break;
case ARL_DELETED:
ret = MSG_AR_EVENT_STATE_DELETED;
break;
default:
/* should never happen */
DTRACE;
break;
}
DRETURN(ret);
}
/*
* Initializes infeasible path detection.
*/
int initInfeas()
{
DSTART( "initInfeas" );
int i, j;
procedure *p;
DOUT( "\nInitializing register set...\n" ); fflush(stdout);
initRegSet();
DOUT( "Allocating data structures...\n" ); fflush( stdout );
MALLOC( num_assign, int**, num_procs * sizeof(int*), "num_assign" );
MALLOC( assignlist, assign****, num_procs * sizeof(assign***), "assignlist" );
MALLOC( branchlist, branch***, num_procs * sizeof(branch**), "branchlist" );
for( i = 0; i < num_procs; i++ ) {
p = procs[i];
CALLOC( num_assign[i], int*, p->num_bb, sizeof(int), "num_assign elm" );
MALLOC( assignlist[i], assign***, p->num_bb * sizeof(assign**), "assignlist elm" );
MALLOC( branchlist[i], branch**, p->num_bb * sizeof(branch*), "branchlist elm" );
for( j = 0; j < p->num_bb; j++ ) {
assignlist[i][j] = NULL;
branchlist[i][j] = NULL;
}
}
DOUT( "Detecting effects...\n" ); fflush( stdout );
execute();
DOUT( "\nFinding related effects...\n" ); fflush( stdout );
detectConflicts();
DOUT( "Detected %d BB and %d BA\n", num_BB, num_BA );
DRETURN( 0 );
}
static inline int
irnet_daddr_to_dname(irnet_socket * self)
{
struct irda_device_info *discoveries;
int number;
int i;
DENTER(IRDA_SERV_TRACE, "(self=0x%p)\n", self);
discoveries = irlmp_get_discoveries(&number, 0xffff,
DISCOVERY_DEFAULT_SLOTS);
if (discoveries == NULL)
DRETURN(-ENETUNREACH, IRDA_SERV_INFO, "Cachelog empty...\n");
for(i = 0; i < number; i++)
{
if(discoveries[i].daddr == self->daddr)
{
strlcpy(self->rname, discoveries[i].info, sizeof(self->rname));
self->rname[sizeof(self->rname) - 1] = '\0';
DEBUG(IRDA_SERV_INFO, "Device 0x%08x is in fact ``%s''.\n",
self->daddr, self->rname);
kfree(discoveries);
DEXIT(IRDA_SERV_TRACE, "\n");
return 0;
}
}
DEXIT(IRDA_SERV_INFO, ": cannot discover device 0x%08x !!!\n", self->daddr);
kfree(discoveries);
return(-EADDRNOTAVAIL);
}
/****** sgeobj/href/href_list_compare() ***************************************
* NAME
* href_list_compare() -- Finds additional entries in list
*
* SYNOPSIS
* bool
* href_list_compare(const lList *this_list, lList **answer_list,
* const lList *list, lList **add_hosts,
* lList **add_groups, lList **equity_hosts,
* lList **equity_groups)
*
* FUNCTION
* This function will find differences between two hostref lists
* given by 'this_list' and 'list'. Hosts and hostgroups which are
* only in 'this_list' can be found in 'add_hosts' and 'add_groups'.
* References which are contained in both lists can be found in
* 'equity_hosts' and 'equity_groups' after a call to this function.
*
* If the calling function is not interested in one ore more of the
* result lists than NULL should be used as parameter. The calling
* function is responsible to free all result lists.
*
* If the callee is also interested in the references which are
* only part of 'list' than this function can not be used.
* href_list_find_diff() should be used in this case.
*
* INPUTS
* const lList *this_list - HR_Type list to comapre
* lList **answer_list - AN_Type list
* const lList *list - 2nd HR_Type list to be compared
* lList **add_hosts - HR_Type list
* lList **add_groups - HR_Type list
* lList **equity_hosts - HR_Type list
* lList **equity_groups - HR_Type list
*
* RESULT
* bool - error state
* true - Success
* false - Error
*
* SEE ALSO
* sgeobj/href/href_list_find_diff()
*******************************************************************************/
bool
href_list_compare(const lList *this_list, lList **answer_list,
const lList *list, lList **add_hosts,
lList **add_groups, lList **equity_hosts,
lList **equity_groups)
{
bool ret = true;
lListElem *this_elem; /* HR_Type */
DENTER(HOSTREF_LAYER, "href_list_compare");
for_each(this_elem, this_list) {
const char *host_or_group = lGetHost(this_elem, HR_name);
if (!href_list_has_member(list, host_or_group)) {
if (is_hgroup_name(host_or_group)) {
if (add_groups != NULL) {
ret = href_list_add(add_groups, answer_list, host_or_group);
}
} else if (add_hosts != NULL) {
ret = href_list_add(add_hosts, answer_list, host_or_group);
}
} else {
if (is_hgroup_name(host_or_group)) {
if (equity_groups != NULL) {
ret = href_list_add(equity_groups, answer_list, host_or_group);
}
} else if (equity_hosts != NULL) {
ret = href_list_add(equity_hosts, answer_list, host_or_group);
}
}
if (!ret) {
break;
}
}
DRETURN(ret);
}
static inline int
irnet_dname_to_daddr(irnet_socket * self)
{
struct irda_device_info *discoveries;
int number;
int i;
DENTER(IRDA_SR_TRACE, "(self=0x%p)\n", self);
discoveries = irlmp_get_discoveries(&number, 0xffff,
DISCOVERY_DEFAULT_SLOTS);
if(discoveries == NULL)
DRETURN(-ENETUNREACH, IRDA_SR_INFO, "Cachelog empty...\n");
for(i = 0; i < number; i++)
{
if(!strncmp(discoveries[i].info, self->rname, NICKNAME_MAX_LEN))
{
self->daddr = discoveries[i].daddr;
DEBUG(IRDA_SR_INFO, "discovered device ``%s'' at address 0x%08x.\n",
self->rname, self->daddr);
kfree(discoveries);
DEXIT(IRDA_SR_TRACE, "\n");
return 0;
}
}
DEBUG(IRDA_SR_INFO, "cannot discover device ``%s'' !!!\n", self->rname);
kfree(discoveries);
return(-EADDRNOTAVAIL);
}
lListElem *
host_list_locate(const lList *host_list, const char *hostname)
{
lListElem *ret = NULL;
DENTER(TOP_LAYER, "host_list_locate");
if (host_list != NULL) {
if (hostname != NULL) {
const lListElem *element = lFirst(host_list);
if (element != NULL) {
int nm = NoName;
if (object_has_type(element, EH_Type)) {
nm = object_get_primary_key(EH_Type);
} else if (object_has_type(element, AH_Type)) {
nm = object_get_primary_key(AH_Type);
} else if (object_has_type(element, SH_Type)) {
nm = object_get_primary_key(SH_Type);
}
ret = lGetElemHost(host_list, nm, hostname);
}
} else {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
}
} else {
/*
* This is a normal case and no error
* if e.g. someone tries to find a element at qmaster startup to
* check if a certain element should be added
*/
ret = NULL;
}
DRETURN(ret);
}
/*
* Function irnet_daddr_to_dname (self)
*
* Convert an IrDA address to a IrDA nickname
*
* It basically look into the discovery log until there is a match.
*/
static inline int
irnet_daddr_to_dname(irnet_socket * self)
{
struct irda_device_info *discoveries; /* Copy of the discovery log */
int number; /* Number of nodes in the log */
int i;
DENTER(IRDA_SERV_TRACE, "(self=0x%X)\n", (unsigned int) self);
/* Ask lmp for the current discovery log */
discoveries = irlmp_get_discoveries(&number, 0xffff);
/* Check if the we got some results */
if (discoveries == NULL)
DRETURN(-ENETUNREACH, IRDA_SERV_INFO, "Cachelog empty...\n");
/* Now, check all discovered devices (if any) */
for(i = 0; i < number; i++)
{
/* Does the name match ? */
if(discoveries[i].daddr == self->daddr)
{
/* Yes !!! Get it.. */
strncpy(self->rname, discoveries[i].info, NICKNAME_MAX_LEN);
self->rname[NICKNAME_MAX_LEN + 1] = '\0';
DEBUG(IRDA_SERV_INFO, "Device 0x%08x is in fact ``%s''.\n",
self->daddr, self->rname);
kfree(discoveries);
DEXIT(IRDA_SERV_TRACE, "\n");
return 0;
}
}
/* No luck ! */
DEXIT(IRDA_SERV_INFO, ": cannot discover device 0x%08x !!!\n", self->daddr);
kfree(discoveries);
return(-EADDRNOTAVAIL);
}
/****** uti/tq/sge_tq_create() *************************************************
* NAME
* sge_tq_create() -- Creates a task queue
*
* SYNOPSIS
* bool sge_tq_create(sge_tq_queue_t **queue)
*
* FUNCTION
* This function creates a task queue.
*
* INPUTS
* sge_tq_queue_t **queue - task queue
*
* RESULT
* bool - error state
* true - success
* false - error
*
* NOTES
* MT-NOTE: sge_tq_create() is MT safe
*
* SEE ALSO
* uti/tq/sge_tq_destroy()
*******************************************************************************/
bool
sge_tq_create(sge_tq_queue_t **queue) {
bool ret = true;
DENTER(TQ_LAYER, "sge_tq_create");
if (queue != NULL) {
sge_tq_queue_t *new_queue;
int size = sizeof(sge_tq_queue_t);
new_queue = (sge_tq_queue_t *)malloc(size);
if (new_queue != NULL) {
sge_sl_create(&new_queue->list);
pthread_cond_init(&new_queue->cond, NULL);
new_queue->waiting = 0;
*queue = new_queue;
} else {
sge_err_set(SGE_ERR_MEMORY, MSG_UNABLETOALLOCATEBYTES_DS, size, SGE_FUNC);
*queue = NULL;
ret = false;
}
}
DRETURN(ret);
}
int main(int argc, char **argv) {
int ret = 0;
lList *pcmdline = NULL;
lList *answer_list = NULL;
sge_gdi_ctx_class_t *ctx = NULL;
qrstat_env_t qrstat_env;
DENTER_MAIN(TOP_LAYER, "qrsub");
/* Set up the program information name */
sge_setup_sig_handlers(QRSTAT);
log_state_set_log_gui(1);
if (sge_gdi2_setup(&ctx, QRSTAT, MAIN_THREAD, &answer_list) != AE_OK) {
answer_list_output(&answer_list);
goto error_exit;
}
qrstat_filter_init(&qrstat_env);
qrstat_filter_set_ctx(&qrstat_env, ctx);
/*
* stage 1: commandline parsing
*/
{
dstring file = DSTRING_INIT;
const char *user = ctx->get_username(ctx);
const char *cell_root = ctx->get_cell_root(ctx);
/* arguments from SGE_ROOT/common/sge_qrstat file */
get_root_file_path(&file, cell_root, SGE_COMMON_DEF_QRSTAT_FILE);
if (sge_parse_from_file_qrstat(sge_dstring_get_string(&file), &pcmdline, &answer_list) == true) {
/* arguments from $HOME/.sge_qrstat file */
if (get_user_home_file_path(&file, SGE_HOME_DEF_QRSTAT_FILE, user, &answer_list)) {
sge_parse_from_file_qrstat(sge_dstring_get_string(&file), &pcmdline, &answer_list);
}
}
sge_dstring_free(&file);
if (answer_list) {
answer_list_output(&answer_list);
lFreeList(&pcmdline);
sge_prof_cleanup();
SGE_EXIT((void**)&ctx, 1);
}
}
answer_list = cull_parse_cmdline(QRSTAT, argv+1, environ, &pcmdline, FLG_USE_PSEUDOS);
if (answer_list != NULL) {
answer_list_output(&answer_list);
lFreeList(&pcmdline);
goto error_exit;
}
/*
* stage 2: evalutate switches and modify qrstat_env
*/
if (!sge_parse_qrstat(ctx, &answer_list, &qrstat_env, &pcmdline)) {
answer_list_output(&answer_list);
lFreeList(&pcmdline);
goto error_exit;
}
/*
* stage 3: fetch data from master
*/
{
answer_list = ctx->gdi(ctx, SGE_AR_LIST, SGE_GDI_GET, &qrstat_env.ar_list,
qrstat_env.where_AR_Type, qrstat_env.what_AR_Type, false);
if (answer_list_has_error(&answer_list)) {
answer_list_output(&answer_list);
goto error_exit;
}
}
/*
* stage 4: create output in correct format
*/
{
qrstat_report_handler_t *handler = NULL;
if (qrstat_env.is_xml) {
handler = qrstat_create_report_handler_xml(&qrstat_env, &answer_list);
} else {
handler = qrstat_create_report_handler_stdout(&qrstat_env, &answer_list);
}
if (!qrstat_print(&answer_list, handler, &qrstat_env)) {
ret = 1;
}
if (qrstat_env.is_xml) {
qrstat_destroy_report_handler_xml(&handler, &answer_list);
} else {
qrstat_destroy_report_handler_stdout(&handler, &answer_list);
}
}
sge_gdi2_shutdown((void**)&ctx);
sge_prof_cleanup();
DRETURN(ret);
error_exit:
sge_gdi2_shutdown((void**)&ctx);
sge_prof_cleanup();
SGE_EXIT((void**)&ctx, 1);
DRETURN(1);
}
cell_t *evaluate(cell_t *exp, environ_t *env) {
++__tl_eval_level;
// push a frame
eval_stack_t s;
s.next = eval_stack;
s.value = env;
eval_stack = &s;
if (DFLAG) {
printf("Eval (%d) got : ", __tl_eval_level);
pretty_print(exp);
}
if (NULL == exp) {
DRETURN(RET_VAL, NULL);
} else if (NILP(exp)) {
DRETURN(RET_VAL, nil_cell);
} else if (ATOMP(exp)) {
if (SYMBOLP(exp)) {
DRETURN(RET_VAL, find_value(env, exp));
} else if (STRINGP(exp) || NUMBERP(exp)) {
DRETURN(RET_VAL, exp);
} else {
DEBUGPRINT_("Expression not valid.\n");
pretty_print(orig_sexpr);
GOTO_TOPLEVEL();
return NULL; /* unreachable */
}
} else { /* list */
handle_t *he = handle_push(exp);
cell_t *first = evaluate(CAR(exp), env); // exp handled
exp = handle_get(he);
handle_pop(he);
cell_t *rest = CDR(exp);
if (DFLAG) {
printf("First is: ");
pretty_print(first);
printf("Rest is: ");
pretty_print(rest);
}
if (NULL == first) {
fast_error(" malformed expression.");
/* This is unreachable */
} else if (PRIMITIVEP(first)) {
cell_t *(*f)(cell_t *, environ_t *) = CELL_PRIMITIVE(first);
DRETURN(RET_PRIM, (*f)(rest, env));
} else if (FUNCTIONP(first)) { /* function call */
cell_t *t;
handle_t *hf;
hf = handle_push(first);
t = evargs(rest, env); // first handled
first = handle_get(hf);
handle_pop(hf);
DRETURN(RET_FUNCALL, invoke(first, t, env)); // no need for handles
}
undefun_error(first, exp); /* Not primitive or funcall, error.*/
return NULL; /* Unreachable, undefun_error() does not return. */
}
}
/**
* @param s: The scrollport to setup
* @param type: To use kinetic scrolling or not
* @return Returns no value
* @brief Sets up default values and callbacks for kinetic scrolling
*/
void
ewl_scrollport_kinetic_scrolling_set(Ewl_Scrollport *s, Ewl_Kinetic_Scroll type)
{
Ewl_Widget *va;
DENTER_FUNCTION(DLEVEL_STABLE);
DCHECK_PARAM_PTR(s);
DCHECK_TYPE(s, EWL_SCROLLPORT_TYPE);
/* If set to current value we have nothing to do */
if ((s->type) && (type == s->type))
DRETURN(DLEVEL_STABLE);
va = EWL_WIDGET(ewl_scrollport_visible_area_get(EWL_SCROLLPORT(s)));
/* Remove all present callbacks and free the kinfo */
if ((s->type == EWL_KINETIC_SCROLL_NORMAL) && (s->kinfo))
{
ewl_callback_del(va, EWL_CALLBACK_MOUSE_DOWN,
ewl_scrollport_kinetic_cb_mouse_down_normal);
ewl_callback_del(va, EWL_CALLBACK_MOUSE_UP,
ewl_scrollport_kinetic_cb_mouse_up_normal);
ewl_callback_del(va, EWL_CALLBACK_MOUSE_MOVE,
ewl_scrollport_kinetic_cb_mouse_move_normal);
}
else if ((s->type == EWL_KINETIC_SCROLL_EMBEDDED) && (s->kinfo))
{
ewl_callback_del(va, EWL_CALLBACK_MOUSE_DOWN,
ewl_scrollport_kinetic_cb_mouse_down_embedded);
ewl_callback_del(va, EWL_CALLBACK_MOUSE_UP,
ewl_scrollport_kinetic_cb_mouse_up_embedded);
ewl_callback_del(va, EWL_CALLBACK_MOUSE_MOVE,
ewl_scrollport_kinetic_cb_mouse_move_embedded);
}
if (s->kinfo)
IF_FREE(s->kinfo->extra);
else
{
s->kinfo = NEW(Ewl_Scrollport_Kinetic_Info, 1);
s->kinfo->fps = 15;
s->kinfo->vmax = 50.0;
s->kinfo->vmin = 0.0;
s->kinfo->dampen = 0.95;
ewl_callback_append(EWL_WIDGET(s), EWL_CALLBACK_DESTROY,
ewl_scrollport_kinetic_cb_destroy, NULL);
}
if (type == EWL_KINETIC_SCROLL_NORMAL)
{
ewl_callback_append(va, EWL_CALLBACK_MOUSE_DOWN,
ewl_scrollport_kinetic_cb_mouse_down_normal, s);
ewl_callback_append(va, EWL_CALLBACK_MOUSE_UP,
ewl_scrollport_kinetic_cb_mouse_up_normal, s);
ewl_callback_append(va, EWL_CALLBACK_MOUSE_MOVE,
ewl_scrollport_kinetic_cb_mouse_move_normal, s);
s->kinfo->extra = NEW(Ewl_Scrollport_Kinetic_Info_Normal, 1);
}
else if (type == EWL_KINETIC_SCROLL_EMBEDDED)
{
ewl_callback_append(va, EWL_CALLBACK_MOUSE_DOWN,
ewl_scrollport_kinetic_cb_mouse_down_embedded,
s);
ewl_callback_append(va, EWL_CALLBACK_MOUSE_UP,
ewl_scrollport_kinetic_cb_mouse_up_embedded, s);
ewl_callback_append(va, EWL_CALLBACK_MOUSE_MOVE,
ewl_scrollport_kinetic_cb_mouse_move_embedded,
s);
s->kinfo->extra = NEW(Ewl_Scrollport_Kinetic_Info_Embedded, 1);
}
s->type = type;
DLEAVE_FUNCTION(DLEVEL_STABLE);
}
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;
}
/****** uti/stdio/sge_peopen() ************************************************
* NAME
* sge_peopen_r() -- Advanced popen()
*
* SYNOPSIS
* pid_t sge_peopen_r(const char *shell, int login_shell,
* const char *command, const char *user,
* char **env, FILE **fp_in, FILE **fp_out,
* FILE **fp_err)
*
* FUNCTION
* Advanced popen() with additional parameters:
* - free shell usage
* - login shell if wanted
* - user under which to start (for root only)
* - stdin and stderr file pointers
* - wait for exactly the process we started
* File descriptors have to be closed with sge_peclose().
*
* This function is reentrant as long as env is not provided to
* this function. This means that the function can be used in
* multi thread processed as long as env is not used.
*
* INPUTS
* const char *shell - which shell to use
* int login_shell - make it a login shell?
* const char *command - name of the program
* const char *user - user under which to start (for root only)
* char **env - env variables to add to child
* FILE **fp_in - file input stream
* FILE **fp_out - file output stream
* FILE **fp_err - file error stream
*
* RESULT
* pid_t - process id
*
* NOTES
* MT-NOTE: sge_peopen() is MT safe
*
* DO NOT ADD ASYNC SIGNAL UNSAFE FUNCTIONS BETWEEN FORK AND EXEC
* DUE TO THE FACT THAT THIS FUNCTION WILL BE USED IN QMASTER
* (MULTITHREADED ENVIRONMENT) THIS MIGHT CAUSE A DEADLOCK
* IN A MASTER THREAD.
*
* SEE ALSO
* uti/stdio/sge_peclose()
******************************************************************************/
pid_t sge_peopen_r(const char *shell, int login_shell, const char *command,
const char *user, char **env, FILE **fp_in, FILE **fp_out,
FILE **fp_err, bool null_stderr)
{
pid_t pid;
int pipefds[3][2];
int i;
char arg0[256];
#if defined(SOLARIS)
char err_str[256];
#endif
struct passwd *pw = NULL;
uid_t myuid;
uid_t tuid;
DENTER(TOP_LAYER, "sge_peopen_r");
if (sge_has_admin_user()) {
sge_switch2start_user();
}
myuid = geteuid();
tuid = myuid;
/*
* open pipes - close on failure
*/
for (i = 0; i < 3; i++) {
if (pipe(pipefds[i]) != 0) {
while (--i >= 0) {
close(pipefds[i][0]);
close(pipefds[i][1]);
}
ERROR((SGE_EVENT, MSG_SYSTEM_FAILOPENPIPES_SS, command, strerror(errno)));
if (sge_has_admin_user()) {
sge_switch2admin_user();
}
DRETURN(-1);
}
}
/*
* set arg0 for exec call correctly to that
* either a normal shell or a login shell will be started
*/
if (login_shell) {
strcpy(arg0, "-");
} else {
strcpy(arg0, "");
}
strcat(arg0, shell);
DPRINTF(("arg0 = %s\n", arg0));
DPRINTF(("arg1 = -c\n"));
DPRINTF(("arg2 = %s\n", command));
/*
* prepare the change of the user which might be done after fork()
* if a user name is provided.
*
* this has to be done before the fork() afterwards it might cause
* a deadlock of the child because getpwnam() is not async-thread safe.
*/
if (user) {
struct passwd pw_struct;
int size = get_pw_buffer_size();
char *buffer = sge_malloc(size);
/*
* get information about the target user
*/
if (buffer != NULL) {
pw = sge_getpwnam_r(user, &pw_struct, buffer, size);
if (pw == NULL) {
ERROR((SGE_EVENT, MSG_SYSTEM_NOUSERFOUND_SS, user, strerror(errno)));
FREE(buffer);
if (sge_has_admin_user()) {
sge_switch2admin_user();
}
DRETURN(-1);
}
} else {
ERROR((SGE_EVENT, MSG_UTI_MEMPWNAM));
FREE(buffer);
if (sge_has_admin_user()) {
sge_switch2admin_user();
}
DRETURN(-1);
}
DPRINTF(("was able to resolve user\n"));
/*
* only prepare change of user if target user is different from current one
*/
if (myuid != pw->pw_uid) {
#if !(defined(WIN32) || defined(INTERIX)) /* var not needed */
int res;
#endif
if (myuid != SGE_SUPERUSER_UID) {
DPRINTF(("only root is allowed to switch to a different user\n"));
ERROR((SGE_EVENT, MSG_SYSTEM_NOROOTRIGHTSTOSWITCHUSER));
FREE(buffer);
DRETURN(-2);
}
DPRINTF(("Before initgroups\n"));
#if !(defined(WIN32) || defined(INTERIX)) /* initgroups not called */
res = initgroups(pw->pw_name, pw->pw_gid);
# if defined(SVR3) || defined(sun)
if (res < 0)
# else
if (res)
# endif
{
ERROR((SGE_EVENT, MSG_SYSTEM_INITGROUPSFORUSERFAILED_ISS, res, user, strerror(errno)));
FREE(buffer);
SGE_EXIT(NULL, 1);
}
DPRINTF(("Initgroups was successful\n"));
#endif /* WIN32 */
}
DPRINTF(("user = %s\n", user));
DPRINTF(("myuid = %d\n", (int)myuid));
if (pw != NULL) {
tuid = pw->pw_uid;
DPRINTF(("target uid = %d\n", (int)tuid));
}
FREE(buffer);
}
DPRINTF(("Now process will fork\n"));
#if defined(SOLARIS)
pid = sge_smf_contract_fork(err_str, 256);
#else
pid = fork();
#endif
/*
* in the child pid is 0
*/
if (pid == 0) {
/*
* close all fd's except that ones mentioned in keep_open
*/
int keep_open[6];
keep_open[0] = 0;
keep_open[1] = 1;
keep_open[2] = 2;
keep_open[3] = pipefds[0][0];
keep_open[4] = pipefds[1][1];
keep_open[5] = pipefds[2][1];
sge_close_all_fds(keep_open, 6);
/*
* shall we redirect stderr to /dev/null? Then
* - open "/dev/null"
* - set stderr to "dev/null"
* - close the stderr-pipe
* otherwise
* - redirect stderr to the pipe
*/
if (null_stderr) {
int fd = open("/dev/null", O_WRONLY);
if (fd != -1) {
close(2);
dup(fd);
close(pipefds[2][1]);
} else {
SGE_EXIT(NULL, 1);
}
} else {
close(2);
dup(pipefds[2][1]);
}
/*
* redirect stdin and stdout to the pipes
*/
close(0);
close(1);
dup(pipefds[0][0]);
dup(pipefds[1][1]);
if (pw != NULL) {
int lret = setuid(tuid);
if (lret) {
SGE_EXIT(NULL, 1);
}
}
/*
* set the environment if we got one as argument
*/
if (env != NULL) {
if (pw != NULL) {
addenv("HOME", pw->pw_dir);
addenv("SHELL", pw->pw_shell);
addenv("USER", pw->pw_name);
addenv("LOGNAME", pw->pw_name);
}
addenv("PATH", SGE_DEFAULT_PATH);
for(; *env; env++) {
putenv(*env);
}
}
execlp(shell, arg0, "-c", command, NULL);
}
if (pid < 0) {
for (i=0; i<3; i++) {
close(pipefds[i][0]);
close(pipefds[i][1]);
}
#if defined(SOLARIS)
if (pid < -1 && err_str) {
ERROR((SGE_EVENT, MSG_SMF_FORK_FAILED_SS, "sge_peopen()", err_str));
}
#endif
if (sge_has_admin_user()) {
sge_switch2admin_user();
}
DRETURN(-1);
}
/* close the childs ends of the pipes */
close(pipefds[0][0]);
close(pipefds[1][1]);
close(pipefds[2][1]);
/* return filehandles for stdin and stdout */
*fp_in = fdopen(pipefds[0][1], "a");
*fp_out = fdopen(pipefds[1][0], "r");
/* is stderr redirected to /dev/null? */
if (null_stderr) {
/* close the pipe and return NULL as filehandle */
close(pipefds[2][0]);
*fp_err = NULL;
} else {
/* return filehandle for stderr */
*fp_err = fdopen(pipefds[2][0], "r");
}
if (sge_has_admin_user()) {
sge_switch2admin_user();
}
DRETURN(pid);
}
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);
}
int main(int argc, char **argv) {
lList *pcmdline = NULL;
lList *alp = NULL;
sge_gdi_ctx_class_t *ctx = NULL;
lList *ar_lp = NULL;
lListElem *ar = NULL;
DENTER_MAIN(TOP_LAYER, "qrsub");
/* Set up the program information name */
sge_setup_sig_handlers(QRSUB);
log_state_set_log_gui(1);
if (sge_gdi2_setup(&ctx, QRSUB, MAIN_THREAD, &alp) != AE_OK) {
answer_list_output(&alp);
goto error_exit;
}
/*
** stage 1 of commandline parsing
*/
{
dstring file = DSTRING_INIT;
const char *user = ctx->get_username(ctx);
const char *cell_root = ctx->get_cell_root(ctx);
/* arguments from SGE_ROOT/common/sge_ar_request file */
get_root_file_path(&file, cell_root, SGE_COMMON_DEF_AR_REQ_FILE);
if ((alp = parse_script_file(QRSUB, sge_dstring_get_string(&file), "", &pcmdline, environ,
FLG_HIGHER_PRIOR | FLG_IGN_NO_FILE)) == NULL) {
/* arguments from $HOME/.sge_ar_request file */
if (get_user_home_file_path(&file, SGE_HOME_DEF_AR_REQ_FILE, user, &alp)) {
lFreeList(&alp);
alp = parse_script_file(QRSUB, sge_dstring_get_string(&file), "", &pcmdline, environ,
FLG_HIGHER_PRIOR | FLG_IGN_NO_FILE);
}
}
sge_dstring_free(&file);
if (alp) {
answer_list_output(&alp);
lFreeList(&pcmdline);
goto error_exit;
}
}
alp = cull_parse_cmdline(QRSUB, argv+1, environ, &pcmdline, FLG_USE_PSEUDOS);
if (answer_list_print_err_warn(&alp, NULL, "qrsub: ", MSG_WARNING) > 0) {
lFreeList(&pcmdline);
goto error_exit;
}
if (!pcmdline) {
/* no command line option is present: print help to stderr */
sge_usage(QRSUB, stderr);
fprintf(stderr, "%s\n", MSG_PARSE_NOOPTIONARGUMENT);
goto error_exit;
}
/*
** stage 2 of command line parsing
*/
ar = lCreateElem(AR_Type);
if (!sge_parse_qrsub(ctx, pcmdline, &alp, &ar)) {
answer_list_output(&alp);
lFreeList(&pcmdline);
goto error_exit;
}
ar_lp = lCreateList(NULL, AR_Type);
lAppendElem(ar_lp, ar);
alp = ctx->gdi(ctx, SGE_AR_LIST, SGE_GDI_ADD | SGE_GDI_RETURN_NEW_VERSION, &ar_lp, NULL, NULL);
lFreeList(&ar_lp);
answer_list_on_error_print_or_exit(&alp, stdout);
if (answer_list_has_error(&alp)) {
sge_gdi2_shutdown((void**)&ctx);
sge_prof_cleanup();
if (answer_list_has_status(&alp, STATUS_NOTOK_DOAGAIN)) {
DRETURN(25);
} else {
DRETURN(1);
}
}
sge_gdi2_shutdown((void**)&ctx);
sge_prof_cleanup();
DRETURN(0);
error_exit:
sge_gdi2_shutdown((void**)&ctx);
sge_prof_cleanup();
SGE_EXIT((void**)&ctx, 1);
DRETURN(1);
}
/****** gdi/request_internal/sge_gdi_packet_pack_task() **********************
* NAME
* sge_gdi_packet_pack_task() -- pack a single GDI task
*
* SYNOPSIS
* bool
* sge_gdi_packet_pack_task(sge_gdi_packet_class_t * packet,
* sge_gdi_task_class_t * task,
* lList **answer_list,
* sge_pack_buffer *pb)
*
* FUNCTION
* This functions packs all data representing one GDI request
* of a mutli GDI request (represented by "packet" and "task")
* into "pb". Errors will be reported with a corresponding
* "answer_list" message and a negative return value.
*
* "pb" has to be initialized before this function is called.
* init_packbuffer() or a similar function has do be used to
* initialize this "pb". The function sge_gdi_packet_get_pb_size()
* might be used to calculate the maximum size as if the buffer
* would be needed to pack all tasks of a multi GDI request.
* Using this size as initial size for the "pb"
* will prevent continuous reallocation of memory in this
* function.
*
* INPUTS
* sge_gdi_packet_class_t * packet - GDI packet
* sge_gdi_task_class_t * task - GDI task
* lList **answer_list - answer_list
* sge_pack_buffer *pb - packing buffer
*
* RESULT
* bool - error state
* true - success
* false - failure
*
* NOTES
* MT-NOTE: sge_gdi_packet_pack_task() is MT safe
*
* SEE ALSO
* gdi/request_internal/sge_gdi_packet_get_pb_size()
* gdi/request_internal/sge_gdi_packet_pack()
*******************************************************************************/
bool
sge_gdi_packet_pack_task(sge_gdi_packet_class_t *packet,
sge_gdi_task_class_t *task, lList **answer_list,
sge_pack_buffer *pb)
{
bool ret = true;
int pack_ret = PACK_SUCCESS;
DENTER(TOP_LAYER, "sge_gdi_packet_pack_task");
if ((task != NULL) && (packet != NULL)
&& (packet->is_intern_request == false)) {
sge_pack_gdi_info(task->command);
/* ===> pack the prefix */
pack_ret = packint(pb, task->command);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, task->target);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, packet->version);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
/*
* if the lSelect call was postponed then it will be done here.
* here we are able to pack the result list directly into the packbuffer.
* additionally it is necessary to add an answer to the answer list.
* (which will be packed below).
*/
if (task->do_select_pack_simultaneous) {
lSelectHashPack("", task->data_list, task->condition,
task->enumeration, false, pb);
lFreeWhat(&(task->enumeration));
lFreeWhere(&(task->condition));
task->data_list = NULL;
/* DIRTY HACK: The "ok" message should be removed from the answer list
* 05/21/2007 qualitiy was ANSWER_QUALITY_INFO but this results in "ok"
* messages on qconf side */
answer_list_add(&(task->answer_list), MSG_GDI_OKNL, STATUS_OK,
ANSWER_QUALITY_END);
} else {
/* ===> pack the list */
pack_ret = cull_pack_list(pb, task->data_list);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
}
/* ===> pack the suffix */
pack_ret = cull_pack_list(pb, task->answer_list);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = cull_pack_cond(pb, task->condition);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = cull_pack_enum(pb, task->enumeration);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packstr(pb, packet->auth_info);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, task->id);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, packet->id);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
pack_ret = packint(pb, (task->next != NULL) ? 1 : 0);
if (pack_ret != PACK_SUCCESS) {
goto error_with_mapping;
}
}
DRETURN(ret);
error_with_mapping:
ret = sge_gdi_map_pack_errors(pack_ret, answer_list);
DRETURN(ret);
}
/*-----------------------------------------------------------------------
* Read name of qmaster from master_file
* -> master_file
* <- return -1 error in err_str
* 0 host name of master in master_host
* don't copy error to err_str if err_str = NULL
* master_file name of file which should point to act_qmaster file
* copy name of qmaster host to master_host
*
* NOTES
* MT-NOTE: get_qm_name() is MT safe
*-----------------------------------------------------------------------*/
int get_qm_name(
char *master_host,
const char *master_file,
char *err_str
) {
FILE *fp;
char buf[CL_MAXHOSTLEN*3+1], *cp, *first;
int len;
DENTER(TOP_LAYER, "get_qm_name");
if (!master_host || !master_file) {
if (err_str) {
if (master_host) {
sprintf(err_str, SFNMAX, MSG_GDI_NULLPOINTERPASSED );
}
}
DRETURN(-1);
}
if (!(fp=fopen(master_file,"r"))) {
ERROR((SGE_EVENT, MSG_GDI_FOPEN_FAILED, master_file, strerror(errno)));
if (err_str) {
sprintf(err_str, MSG_GDI_OPENMASTERFILEFAILED_S , master_file);
}
DRETURN(-1);
}
/* read file in one sweep and append O Byte to the end */
if (!(len = fread(buf, 1, CL_MAXHOSTLEN*3, fp))) {
if (err_str) {
sprintf(err_str, MSG_GDI_READMASTERHOSTNAMEFAILED_S , master_file);
}
}
buf[len] = '\0';
/* Skip white space including newlines */
cp = buf;
while (*cp && (*cp == ' ' || *cp == '\t' || *cp == '\n'))
cp++;
first = cp;
/* read all non white space characters */
while (*cp && !(*cp == ' ' || *cp == '\t' || *cp == '\n')) {
cp++;
}
*cp = '\0';
len = cp - first;
if (len == 0) {
if (err_str) {
sprintf(err_str, MSG_GDI_MASTERHOSTNAMEHASZEROLENGTH_S , master_file);
}
FCLOSE(fp);
DRETURN(-1);
}
if (len > CL_MAXHOSTLEN - 1) {
if (err_str) {
sprintf(err_str, MSG_GDI_MASTERHOSTNAMEEXCEEDSCHARS_SI ,
master_file, (int) CL_MAXHOSTLEN);
sprintf(err_str, "\n");
}
FCLOSE(fp);
DRETURN(-1);
}
FCLOSE(fp);
strcpy(master_host, first);
DRETURN(0);
FCLOSE_ERROR:
DRETURN(-1);
}
/****** sge_manop_qmaster/sge_del_manop() **************************************
* NAME
* sge_del_manop() -- delete manager or operator
*
* SYNOPSIS
* int
* sge_del_manop(sge_gdi_ctx_class_t *ctx, lListElem *ep, lList **alpp,
* char *ruser, char *rhost, u_long32 target)
*
* FUNCTION
* Deletes a manager or an operator from the corresponding master list.
*
* INPUTS
* sge_gdi_ctx_class_t *ctx - gdi context
* lListElem *ep - the manager/operator to delete
* lList **alpp - answer list to return messages
* char *ruser - user having triggered the action
* char *rhost - host from which the action has been triggered
* u_long32 target - SGE_UM_LIST or SGE_UO_LIST
*
* RESULT
* int - STATUS_OK or STATUS_* error code
*
* NOTES
* MT-NOTE: sge_del_manop() is MT safe - if we hold the global lock.
*******************************************************************************/
int sge_del_manop(sge_gdi_ctx_class_t *ctx, lListElem *ep, lList **alpp, char *ruser, char *rhost, u_long32 target)
{
lListElem *found;
int pos;
const char *manop_name;
const char *object_name;
lList **lpp = NULL;
int key = NoName;
ev_event eve = sgeE_EVENTSIZE;
DENTER(TOP_LAYER, "sge_del_manop");
if (ep == NULL || ruser == NULL || rhost == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
switch (target) {
case SGE_UM_LIST:
lpp = object_type_get_master_list(SGE_TYPE_MANAGER);
object_name = MSG_OBJ_MANAGER;
key = UM_name;
eve = sgeE_MANAGER_DEL;
break;
case SGE_UO_LIST:
lpp = object_type_get_master_list(SGE_TYPE_OPERATOR);
object_name = MSG_OBJ_OPERATOR;
key = UO_name;
eve = sgeE_OPERATOR_DEL;
break;
default :
DPRINTF(("unknown target passed to %s\n", SGE_FUNC));
DRETURN(STATUS_EUNKNOWN);
}
/* ep is no manop element, if ep has no UM_name/UO_name */
if ((pos = lGetPosViaElem(ep, key, SGE_NO_ABORT)) < 0) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_MISSINGCULLFIELD_SS, lNm2Str(key), SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
manop_name = lGetPosString(ep, pos);
if (manop_name == NULL) {
CRITICAL((SGE_EVENT, MSG_SGETEXT_NULLPTRPASSED_S, SGE_FUNC));
answer_list_add(alpp, SGE_EVENT, STATUS_EUNKNOWN, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EUNKNOWN);
}
/* prevent removing of root from man/op-list */
if (strcmp(manop_name, "root") == 0) {
ERROR((SGE_EVENT, MSG_SGETEXT_MAY_NOT_REMOVE_USER_FROM_LIST_SS, "root", object_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
/* prevent removing the admin user from man/op-list */
if (strcmp(manop_name, ctx->get_admin_user(ctx)) == 0) {
ERROR((SGE_EVENT, MSG_SGETEXT_MAY_NOT_REMOVE_USER_FROM_LIST_SS,
ctx->get_admin_user(ctx), object_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
found = lGetElemStr(*lpp, key, manop_name);
if (!found) {
ERROR((SGE_EVENT, MSG_SGETEXT_DOESNOTEXIST_SS, object_name, manop_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EEXIST, ANSWER_QUALITY_ERROR);
DRETURN(STATUS_EEXIST);
}
lDechainElem(*lpp, found);
/* update on file */
if (!sge_event_spool(ctx, alpp, 0, eve,
0, 0, manop_name, NULL, NULL,
NULL, NULL, NULL, true, true)) {
ERROR((SGE_EVENT, MSG_CANTSPOOL_SS, object_name, manop_name));
answer_list_add(alpp, SGE_EVENT, STATUS_EDISK, ANSWER_QUALITY_ERROR);
/* chain in again */
lAppendElem(*lpp, found);
DRETURN(STATUS_EDISK);
}
lFreeElem(&found);
INFO((SGE_EVENT, MSG_SGETEXT_REMOVEDFROMLIST_SSSS, ruser, rhost, manop_name, object_name));
answer_list_add(alpp, SGE_EVENT, STATUS_OK, ANSWER_QUALITY_INFO);
DRETURN(STATUS_OK);
}
/****** gdi/sge/sge_qexecve() ************************************************
* NAME
* sge_qexecve() -- start a task in a tightly integrated par. job
*
* SYNOPSIS
* sge_tid_t sge_qexecve(const char *hostname, const char *queuename,
* const char *cwd, const lList *environment
* const lList *path_aliases)
*
* FUNCTION
* Starts a task in a tightly integrated job.
* Builds a job object describing the task,
* connects to the commd on the targeted execution host,
* deliveres the job object and waits for an answer.
* The answer from the execution daemon on the execution host
* contains a task id that is returned to the caller of the function.
*
* INPUTS
* const char *hostname - name of the host on which to start the task
* const lList *environment - list containing environment variable
* settings for the task that override the
* default environment
* const lList *path_aliases - optional a path alias list
*
* RESULT
* sge_tid_t - the task id, if the task can be executed,
* a value <= 0 indicates an error.
*
* NOTES
* MT-NOTE: sge_qexecve() is not MT safe
******************************************************************************/
sge_tid_t sge_qexecve(sge_gdi_ctx_class_t *ctx,
const char *hostname, const char *queuename,
const char *cwd, const lList *environment,
const lList *path_aliases)
{
char myname[256];
const char *s;
int ret, uid;
sge_tid_t tid = NULL;
lListElem *petrep;
lListElem *rt;
sge_pack_buffer pb;
u_long32 jobid, jataskid;
u_long32 dummymid = 0;
const char *env_var_name = "SGE_TASK_ID";
DENTER(TOP_LAYER, "sge_qexecve");
if (hostname == NULL) {
sprintf(lasterror, MSG_GDI_INVALIDPARAMETER_SS, "sge_qexecve", "hostname");
DRETURN(NULL);
}
/* resolve user */
if (sge_uid2user((uid=getuid()), myname, sizeof(myname)-1, MAX_NIS_RETRIES)) {
sprintf(lasterror, MSG_GDI_RESOLVINGUIDTOUSERNAMEFAILED_IS ,
uid, strerror(errno));
DRETURN(NULL);
}
if ((s=getenv("JOB_ID")) == NULL) {
sprintf(lasterror, MSG_GDI_MISSINGINENVIRONMENT_S, "JOB_ID");
DRETURN(NULL);
}
if (sscanf(s, sge_u32, &jobid) != 1) {
sprintf(lasterror, MSG_GDI_STRINGISINVALID_SS, s, "JOB_ID");
DRETURN(NULL);
}
if ((s=getenv(env_var_name)) != NULL) {
if (strcmp(s, "undefined") == 0) {
jataskid = 1;
} else {
if (sscanf(s, sge_u32, &jataskid) != 1) {
sprintf(lasterror, MSG_GDI_STRINGISINVALID_SS, s, env_var_name);
DRETURN(NULL);
}
}
} else {
sprintf(lasterror, MSG_GDI_MISSINGINENVIRONMENT_S, env_var_name);
DRETURN(NULL);
}
/* ---- build up pe task request structure (see gdilib/sge_petaskL.h) */
petrep = lCreateElem(PETR_Type);
lSetUlong(petrep, PETR_jobid, jobid);
lSetUlong(petrep, PETR_jataskid, jataskid);
lSetString(petrep, PETR_owner, myname);
lSetUlong(petrep, PETR_submission_time, sge_get_gmt());
if (cwd != NULL) {
lSetString(petrep, PETR_cwd, cwd);
}
if (environment != NULL) {
lSetList(petrep, PETR_environment, lCopyList("environment", environment));
}
if (path_aliases != NULL) {
lSetList(petrep, PETR_path_aliases, lCopyList("path_aliases", path_aliases));
}
if (queuename != NULL) {
lSetString(petrep, PETR_queuename, queuename);
}
if (init_packbuffer(&pb, 1024, 0) != PACK_SUCCESS) {
lFreeElem(&petrep);
sprintf(lasterror, SFNMAX, MSG_GDI_OUTOFMEMORY);
DRETURN(NULL);
}
pack_job_delivery(&pb, petrep);
ret = gdi2_send_message_pb(ctx, 1, prognames[EXECD], 1, hostname,
TAG_JOB_EXECUTION, &pb, &dummymid);
clear_packbuffer(&pb);
lFreeElem(&petrep);
if (ret != CL_RETVAL_OK) {
sprintf(lasterror, MSG_GDI_SENDTASKTOEXECDFAILED_SS, hostname, cl_get_error_text(ret));
DRETURN(NULL);
}
/* add list into our remote task list */
rt = lAddElemStr(&remote_task_list, RT_tid, "none", RT_Type);
lSetHost(rt, RT_hostname, hostname);
lSetUlong(rt, RT_state, RT_STATE_WAIT4ACK);
rcv_from_execd(ctx, OPT_SYNCHRON, TAG_JOB_EXECUTION);
tid = (sge_tid_t) lGetString(rt, RT_tid);
if (strcmp(tid, "none") == 0) {
tid = NULL;
sprintf(lasterror, MSG_GDI_EXECDONHOSTDIDNTACCEPTTASK_S, hostname);
}
/* now close message to execd */
cl_commlib_shutdown_handle(cl_com_get_handle("execd_handle", 0), false);
DRETURN(tid);
}
/*-------------------------------------------------------------------------*/
static Boolean qmonSchedGet(lListElem *sep) {
int job_info;
lList *alp = NULL;
String str;
char buf[BUFSIZ];
DENTER(GUI_LAYER, "qmonSchedGet");
if (!sep) {
goto error_exit;
}
/*
** get entries from dialog
*/
XmtDialogGetDialogValues(qmon_sconf, &data);
/**
printf("<-data.algorithm: '%s'\n", data.algorithm ? data.algorithm : "-NA-");
printf("<-data.schedule_interval: '%s'\n", data.schedule_interval ? data.schedule_interval : "-NA-");
printf("<-data.sc_params: '%s'\n", data.sc_params ? data.sc_params : "-NA-");
printf("<-data.maxujobs: '%d'\n", data.maxujobs );
printf("<-data.flush_submit_secs: '%d'\n", data.flush_submit_secs );
printf("<-data.flush_finish_secs: '%d'\n", data.flush_finish_secs );
printf("<-data.max_reservation: '%d'\n", data.max_reservation );
printf("<-data.queue_sort_method: '%d'\n", data.queue_sort_method );
printf("<-data.load_adjustment_decay_time: '%s'\n", data.load_adjustment_decay_time ? data.load_adjustment_decay_time : "-NA-");
printf("<-data.load_formula: '%s'\n", data.load_formula ? data.load_formula : "-NA-");
**/
if (!data.algorithm || data.algorithm[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Algorithm required!}");
goto error_exit;
}
lSetString(sep, SC_algorithm, data.algorithm);
if (!data.schedule_interval || data.schedule_interval[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Schedule Interval required!}");
goto error_exit;
}
lSetString(sep, SC_schedule_interval, data.schedule_interval);
lSetString(sep, SC_params, data.sc_params);
lSetUlong(sep, SC_maxujobs, (u_long32) data.maxujobs);
lSetUlong(sep, SC_flush_submit_sec, (u_long32) data.flush_submit_secs);
lSetUlong(sep, SC_flush_finish_sec, (u_long32) data.flush_finish_secs);
lSetUlong(sep, SC_max_reservation, (u_long32) data.max_reservation);
lSetUlong(sep, SC_queue_sort_method, (u_long32) data.queue_sort_method);
/*
** load adjustments need special treatment
*/
lSetList(sep, SC_job_load_adjustments, data.job_load_adjustments);
data.job_load_adjustments = NULL;
if (!data.load_adjustment_decay_time ||
data.load_adjustment_decay_time[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Load Adjustment Decay Time required!}");
goto error_exit;
}
lSetString(sep, SC_load_adjustment_decay_time,
data.load_adjustment_decay_time);
if (!data.load_formula || data.load_formula[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Load Formula required!}");
goto error_exit;
}
lSetString(sep, SC_load_formula, data.load_formula);
if (!data.reprioritize_interval||
data.reprioritize_interval[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Reprioritize Interval required!}");
goto error_exit;
}
lSetString(sep, SC_reprioritize_interval, data.reprioritize_interval);
if (!data.default_duration||
data.default_duration[0] == '\0') {
qmonMessageShow(qmon_sconf, True, "@{Default duration required!}");
goto error_exit;
}
lSetString(sep, SC_default_duration, data.default_duration);
/*
** schedd_job_info needs some extras
** see comment for schedd_job_info in qmonScheddSet
*/
job_info = XmtChooserGetState(sconf_job_info);
switch (job_info) {
case 0:
lSetString(sep, SC_schedd_job_info, "false");
break;
case 1:
lSetString(sep, SC_schedd_job_info, "true");
break;
case 2:
str = XmtInputFieldGetString(sconf_job_range);
{
lList *range_list = NULL;
range_list_parse_from_string(&range_list, &alp, str,
1, 0, INF_NOT_ALLOWED);
lFreeList(&range_list);
}
if (alp) {
qmonMessageShow(sconf_job_range, True, (StringConst)lGetString(lFirst(alp), AN_text));
lFreeList(&alp);
goto error_exit;
}
if (str && str[0] != '\0') {
strcpy(buf, "job_list ");
strcat(buf, str);
lSetString(sep, SC_schedd_job_info, buf);
}
else {
qmonMessageShow(qmon_sconf, True, "@{Job Range required!}");
goto error_exit;
}
}
/* printf("------> qmonSchedGet\n"); */
/* lWriteElemTo(sep, stdout); */
qmonSchedFreeData();
DRETURN(True);
error_exit:
qmonSchedFreeData();
DRETURN(False);
}
/*-------------------------------------------------------------------------*/
static Boolean qmonSchedSet(lListElem *sep) {
static char schedd_job_info[BUFSIZ];
DENTER(GUI_LAYER, "qmonSchedSet");
if (!sep) {
DRETURN(False);
}
/* printf("------> qmonSchedSet\n"); */
/* lWriteElemTo(sep, stdout); */
data.algorithm = sge_strdup(data.algorithm,
(StringConst)lGetString(sep, SC_algorithm));
data.schedule_interval = sge_strdup(data.schedule_interval,
(StringConst)lGetString(sep, SC_schedule_interval));
data.sc_params = sge_strdup(data.sc_params,
(StringConst)lGetString(sep, SC_params));
data.maxujobs = lGetUlong(sep, SC_maxujobs);
data.flush_submit_secs = lGetUlong(sep, SC_flush_submit_sec);
data.flush_finish_secs = lGetUlong(sep, SC_flush_finish_sec);
data.max_reservation = lGetUlong(sep, SC_max_reservation);
/* this depends on the kind queue_sort_method is represented */
data.queue_sort_method = lGetUlong(sep, SC_queue_sort_method);
/*
** load adjustments need special treatment
*/
data.job_load_adjustments = lCopyList("copy", lGetList(sep, SC_job_load_adjustments));
data.load_adjustment_decay_time = sge_strdup(data.load_adjustment_decay_time,
(StringConst)lGetString(sep, SC_load_adjustment_decay_time));
data.load_formula = sge_strdup(data.load_formula,
(StringConst)lGetString(sep, SC_load_formula));
data.reprioritize_interval = sge_strdup(data.reprioritize_interval,
(StringConst)lGetString(sep, SC_reprioritize_interval));
data.default_duration = sge_strdup(data.default_duration,
(StringConst)lGetString(sep, SC_default_duration));
/**
printf("->data.algorithm: '%s'\n", data.algorithm ? data.algorithm : "-NA-");
printf("->data.schedule_interval: '%s'\n", data.schedule_interval ? data.schedule_interval : "-NA-");
printf("->data.sc_params: '%s'\n", data.sc_params ? data.sc_params : "-NA-");
printf("->data.maxujobs: '%d'\n", data.maxujobs );
printf("->data.flush_submit_secs: '%d'\n", data.flush_submit_secs );
printf("->data.flush_finish_secs: '%d'\n", data.flush_finish_secs );
printf("->data.max_reservation: '%d'\n", data.max_reservation );
printf("->data.queue_sort_method: '%d'\n", data.queue_sort_method );
printf("->data.load_adjustment_decay_time: '%s'\n", data.load_adjustment_decay_time ? data.load_adjustment_decay_time : "-NA-");
printf("->data.load_formula: '%s'\n", data.load_formula ? data.load_formula : "-NA-");
**/
/*
** set the dialog values
*/
XmtDialogSetDialogValues(qmon_sconf, (XtPointer) &data);
/*
** schedd_job_info needs some extras
** attention: order must match order of labels in qmon_sconf.ad
**
** Qmon*sconf_general*sconf_job_info.chooserType: ChooserOption
** Qmon*sconf_general*sconf_job_info.strings: \
** "False", \
** "True", \
** "Job Range"
*/
if (lGetString(sep, SC_schedd_job_info))
sge_strlcpy(schedd_job_info, lGetString(sep, SC_schedd_job_info), BUFSIZ);
else
strcpy(schedd_job_info, "false");
if (!strcasecmp(schedd_job_info, "false")) {
XmtChooserSetState(sconf_job_info, 0, True);
XmtInputFieldSetString(sconf_job_range, "");
}
else if (!strcasecmp(schedd_job_info, "true")) {
XmtChooserSetState(sconf_job_info, 1, True);
XmtInputFieldSetString(sconf_job_range, "");
}
else {
char *sji;
strtok(schedd_job_info, " \t");
sji = strtok(NULL, "\n");
XmtChooserSetState(sconf_job_info, 2, True);
XmtInputFieldSetString(sconf_job_range, sji);
}
qmonSchedFreeData();
DRETURN(True);
}
/****** run_ijs_server() *******************************************************
* NAME
* run_ijs_server() -- The servers main loop
*
* SYNOPSIS
* int run_ijs_server(u_long32 job_id, int nostdin, int noshell,
* int is_rsh, int is_qlogin, int force_pty,
* int *p_exit_status)
*
* FUNCTION
* The main loop of the commlib server, handling the data transfer from
* and to the client.
*
* INPUTS
* COMM_HANDLE *handle - Handle of the COMM server
* u_long32 job_id - SGE job id of this job
* int nostdin - The "-nostdin" switch
* int noshell - The "-noshell" switch
* int is_rsh - Is it a qrsh with commandline?
* int is_qlogin - Is it a qlogin or qrsh without commandline?
* int suspend_remote - suspend_remote switch of qrsh
* int force_pty - The user forced use of pty by the "-pty yes" switch
*
* OUTPUTS
* int *p_exit_status - The exit status of qrsh_starter in case of
* "qrsh <command>" or the exit status of the shell in
* case of "qrsh <no command>"/"qlogin".
* If the job was signalled, the exit code is 128+signal.
*
* RESULT
* int - 0: Ok.
* 1: Invalid parameter
* 2: Log list not initialized
* 3: Error setting terminal mode
* 4: Can't create tty_to_commlib thread
* 5: Can't create commlib_to_tty thread
* 6: Error shutting down commlib connection
* 7: Error resetting terminal mode
*
* NOTES
* MT-NOTE: run_ijs_server is not MT-safe
*******************************************************************************/
int run_ijs_server(COMM_HANDLE *handle, const char *remote_host,
u_long32 job_id,
int nostdin, int noshell,
int is_rsh, int is_qlogin, ternary_t force_pty,
ternary_t suspend_remote,
int *p_exit_status, dstring *p_err_msg)
{
int ret = 0, ret_val = 0;
THREAD_HANDLE *pthread_tty_to_commlib = NULL;
THREAD_HANDLE *pthread_commlib_to_tty = NULL;
THREAD_LIB_HANDLE *thread_lib_handle = NULL;
cl_raw_list_t *cl_com_log_list = NULL;
DENTER(TOP_LAYER, "run_ijs_server");
if (handle == NULL || p_err_msg == NULL || p_exit_status == NULL || remote_host == NULL) {
return 1;
}
g_comm_handle = handle;
g_hostname = strdup(remote_host);
cl_com_log_list = cl_com_get_log_list();
if (cl_com_log_list == NULL) {
return 2;
}
g_nostdin = nostdin;
g_noshell = noshell;
g_pid = getpid();
g_is_rsh = is_rsh;
if (suspend_remote == UNSET || suspend_remote == NO) {
g_suspend_remote = 0;
} else {
g_suspend_remote = 1;
}
/*
* qrsh without command and qlogin both have is_rsh == 0 and is_qlogin == 1
* qrsh with command and qsh don't need to set terminal mode.
* If the user requested a pty we also have to set terminal mode.
* But only if stdout is still connected to a tty and not redirected
* to a file or a pipe.
*/
if (isatty(STDOUT_FILENO) == 1 &&
((force_pty == UNSET && is_rsh == 0 && is_qlogin == 1) || force_pty == YES)) {
/*
* Set this terminal to raw mode, just output everything, don't interpret
* it. Let the pty on the client side interpret the characters.
*/
ret = terminal_enter_raw_mode();
if (ret != 0) {
sge_dstring_sprintf(p_err_msg, "can't set terminal to raw mode: %s (%d)",
strerror(ret), ret);
return 3;
} else {
g_raw_mode_state = 1;
}
}
/*
* Setup thread list and create two worker threads
*/
thread_init_lib(&thread_lib_handle);
/*
* From here on, we have to cleanup the list in case of errors, this is
* why we "goto cleanup" in case of error.
*/
DPRINTF(("creating worker threads\n"));
DPRINTF(("creating tty_to_commlib thread\n"));
ret = create_thread(thread_lib_handle, &pthread_tty_to_commlib, cl_com_log_list,
"tty_to_commlib thread", 1, tty_to_commlib);
if (ret != CL_RETVAL_OK) {
sge_dstring_sprintf(p_err_msg, "can't create tty_to_commlib thread: %s",
cl_get_error_text(ret));
ret_val = 4;
goto cleanup;
}
DPRINTF(("creating commlib_to_tty thread\n"));
ret = create_thread(thread_lib_handle, &pthread_commlib_to_tty, cl_com_log_list,
"commlib_to_tty thread", 1, commlib_to_tty);
if (ret != CL_RETVAL_OK) {
sge_dstring_sprintf(p_err_msg, "can't create commlib_to_tty thread: %s",
cl_get_error_text(ret));
ret_val = 5;
goto cleanup;
}
/*
* From here on, the two worker threads are doing all the work.
* This main thread is just waiting until the client closes the
* connection to us, which causes the commlib_to_tty thread to
* exit. Then it closes the tty_to_commlib thread, too, and
* cleans up everything.
*/
DPRINTF(("waiting for end of commlib_to_tty thread\n"));
thread_join(pthread_commlib_to_tty);
DPRINTF(("shutting down tty_to_commlib thread\n"));
thread_shutdown(pthread_tty_to_commlib);
/*
* Close stdin to awake the tty_to_commlib-thread from the select() call.
* thread_shutdown() doesn't work on all architectures.
*/
close(STDIN_FILENO);
DPRINTF(("waiting for end of tty_to_commlib thread\n"));
thread_join(pthread_tty_to_commlib);
cleanup:
/*
* Set our terminal back to 'unraw' mode. Should be done automatically
* by OS on process end, but we want to be sure.
*/
ret = terminal_leave_raw_mode();
DPRINTF(("terminal_leave_raw_mode() returned %s (%d)\n", strerror(ret), ret));
if (ret != 0) {
sge_dstring_sprintf(p_err_msg, "error resetting terminal mode: %s (%d)", strerror(ret));
ret_val = 7;
}
*p_exit_status = g_exit_status;
thread_cleanup_lib(&thread_lib_handle);
DRETURN(ret_val);
}
/****** gdi/request_internal/sge_gdi_packet_unpack() *************************
* NAME
* sge_gdi_packet_unpack() -- unpacks a GDI packet
*
* SYNOPSIS
* bool
* sge_gdi_packet_unpack(sge_gdi_packet_class_t **packet,
* lList **answer_list, sge_pack_buffer *pb)
*
* FUNCTION
* This functions unpacks all data representing a single or multi
* GDI request. The information is parsed from the given packing
* buffer "pb" and ist stored into "packet". Necessary memory will
* be allocated.
*
* INPUTS
* sge_gdi_packet_class_t ** packet - new GDI packet
* lList **answer_list - answer_list
* sge_pack_buffer *pb - packing buffer
*
* RESULT
* bool - error state
* true - success
* false - error
*
* NOTES
* MT-NOTE: sge_gdi_packet_unpack() is MT safe
*
* SEE ALSO
* gdi/request_internal/sge_gdi_packet_get_pb_size()
* gdi/request_internal/sge_gdi_packet_pack_task()
* gdi/request_internal/sge_gdi_packet_pack()
*******************************************************************************/
bool
sge_gdi_packet_unpack(sge_gdi_packet_class_t **packet, lList **answer_list,
sge_pack_buffer *pb)
{
bool aret = true;
bool has_next;
int pack_ret;
DENTER(TOP_LAYER, "sge_gdi_packet_unpack");
*packet = sge_gdi_packet_create_base(answer_list);
if (*packet != NULL) {
bool first = true;
do {
u_long32 target = 0;
u_long32 command = 0;
lList *data_list = NULL;
u_long32 version = 0;
lList *a_list = NULL;
lCondition *condition = NULL;
lEnumeration *enumeration = NULL;
char *auth_info = NULL;
u_long32 task_id = 0;
u_long32 packet_id = 0;
u_long32 has_next_int = 0;
if ((pack_ret = unpackint(pb, &(command)))) {
goto error_with_mapping;
}
if ((pack_ret = unpackint(pb, &(target)))) {
goto error_with_mapping;
}
if ((pack_ret = unpackint(pb, &(version)))) {
goto error_with_mapping;
}
/* JG: TODO (322): At this point we should check the version!
** The existent check function sge_gdi_packet_verify_version
** cannot be called as neccesary data structures are
** available here (e.g. answer list).
** Better do these changes at a more general place
** together with (hopefully coming) further communication
** redesign.
*/
if ((pack_ret = cull_unpack_list(pb, &(data_list)))) {
goto error_with_mapping;
}
if ((pack_ret = cull_unpack_list(pb, &(a_list)))) {
goto error_with_mapping;
}
if ((pack_ret = cull_unpack_cond(pb, &(condition)))) {
goto error_with_mapping;
}
if ((pack_ret = cull_unpack_enum(pb, &(enumeration)))) {
goto error_with_mapping;
}
if ((pack_ret = unpackstr(pb, &(auth_info)))) {
goto error_with_mapping;
}
if ((pack_ret = unpackint(pb, &(task_id)))) {
goto error_with_mapping;
}
if ((pack_ret = unpackint(pb, &(packet_id)))) {
goto error_with_mapping;
}
if ((pack_ret = unpackint(pb, &has_next_int))) {
goto error_with_mapping;
}
has_next = (has_next_int > 0) ? true : false;
if (first) {
(*packet)->id = packet_id;
(*packet)->version = version;
(*packet)->auth_info = auth_info;
auth_info = NULL;
first = false;
} else {
auth_info = (char *) sge_free((char *) auth_info);
}
/* EB: TODO: ST: cleanup - set last parameter to true */
aret = sge_gdi_packet_append_task(*packet, &a_list, target,
command, &data_list, &a_list,
&condition, &enumeration,
false, false);
if (aret == false) {
goto error;
}
} while (has_next);
}
DRETURN(aret);
error_with_mapping:
aret = sge_gdi_map_pack_errors(pack_ret, answer_list);
error:
sge_gdi_packet_free(packet);
DRETURN(aret);
}
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);
}
/* Remove the task's controller directory after moving out the
shepherd and killing anything left. */
bool
remove_shepherd_cpuset(u_long32 job, u_long32 task, pid_t pid)
{
char dir[SGE_PATH_MAX], taskfile[SGE_PATH_MAX], spid[PID_BSIZE];
FILE *fp;
bool rogue = false;
DENTER(TOP_LAYER, "remove_shepherd_cpuset");
snprintf(dir, sizeof dir, "%s/"sge_u32"."sge_u32"/"pid_t_fmt,
cgroup_dir(cg_cpuset), job, task, pid);
build_path(taskfile, dir, "tasks");
/* We should have an empty task list. If we can't remove it, kill
anything there. Arguably this should be repeated in case of a
race against things spawning if we don't have the freezer cgroup. */
errno = 0;
if (rmdir(dir) == 0) DRETURN(true);
/* EBUSY means it still has tasks. */
if (errno != EBUSY) {
ERROR((SGE_EVENT, MSG_FILE_RMDIRFAILED_SS, dir, strerror(errno)));
DRETURN(false);
}
if (!(fp = fopen(taskfile, "r"))) {
WARNING((SGE_EVENT, MSG_FILE_NOOPEN_SS, taskfile, strerror(errno)));
DRETURN(false);
}
while (fgets(spid, sizeof spid, fp)) {
char buf[MAX_STRING_SIZE], file[SGE_PATH_MAX], *v, *cmd;
pid_t tgid;
size_t l;
replace_char(spid, strlen(spid), '\n', '\0');
/* Move the task away to avoid waiting for it to die. */
/* Fixme: Keep the cpusetdir tasks open and just write to that. */
reparent_proc(spid, cgroup_dir(cg_cpuset));
/* Kill rogue processes, avoiding the shepherd. (Shepherd needs
to be killed exactly once, otherwise sge_reap_children_execd
is called multiple times.) Only consider entries in the task
list that are processes (Tgid == Pid), not threads; this
copes with old-style cpusets, lacking cgroup.procs. */
snprintf(file, sizeof file, "/proc/%s/status", spid);
v = file_getvalue(buf, MAX_STRING_SIZE, file, "Tgid:");
if (! v) continue;
tgid = atoi(v);
if (strcmp(v, spid) /* process */
&& (tgid != pid)) { /* not shepherd */
if (!rogue)
WARNING((SGE_EVENT, "rogue process(es) found for task "
sge_u32"."sge_u32, job, task));
rogue = true;
/* Extract and log process name */
snprintf(file, sizeof file, "/proc/%s/cmdline", spid);
errno = 0;
l = sizeof buf;
cmd = dev_file2string(file, buf, &l);
if (l)
INFO((SGE_EVENT, "rogue: "SFN2, replace_char(cmd, l, '\0', ' ')));
sge_switch2start_user();
kill(tgid, SIGKILL);
sge_switch2admin_user();
}
}
fclose(fp);
errno = 0;
if (rmdir(dir) == 0) DRETURN(true);
ERROR((SGE_EVENT, MSG_FILE_RMDIRFAILED_SS, dir, strerror(errno)));
DRETURN(false);
}
int main(int argc, char *argv[])
{
int pos_tests_failed = 0;
int neg_tests_failed = 0;
int i = 0;
lList *answer_list = NULL;
filter_test_t positiv_test[] = {
{"num_proc", 4},
{"$num_proc", 4},
{"$num_proc*2", 8},
{"$num_proc*0.5", 2.0},
{"num_proc*2", 8},
{"num_proc+1", 5},
{"$num_proc-2", 2},
{"$num_proc+0.1", 4.1},
{"1+$num_proc+0.1", 5.1},
{NULL, 0}
};
filter_test_t negativ_test[] = {
{"2*num_proc", 0},
{"2,0+num_proc", 0},
{"none", 0},
{NULL, 0}
};
lList *centry_list;
lList *host_centry_list;
lListElem *centry;
lListElem *host;
DENTER_MAIN(TOP_LAYER, "test_sge_load_formula");
lInit(nmv);
/* set up centry */
centry_list = lCreateList("", CE_Type);
centry = lCreateElem(CE_Type);
lSetString(centry, CE_name, "num_proc");
lSetString(centry, CE_stringval, "4");
lSetDouble(centry, CE_doubleval, 4);
lAppendElem(centry_list, centry);
/* set up host */
host_centry_list = lCreateList("", CE_Type);
lAppendElem(host_centry_list, lCopyElem(centry));
host = lCreateElem(EH_Type);
lSetList(host, EH_consumable_config_list, host_centry_list);
for (i=0; ; i++){
double val;
if (positiv_test[i].formula == NULL) {
break;
}
if (!validate_load_formula(positiv_test[i].formula, &answer_list, centry_list, "load_formula")) {
answer_list_output(&answer_list);
pos_tests_failed++;
}
val = scaled_mixed_load(positiv_test[i].formula, NULL, host, centry_list);
if (val != positiv_test[i].value) {
printf("got %f, but expected %f(%g,%g)\n", val, positiv_test[i].value, val, positiv_test[i].value);
pos_tests_failed++;
}
}
for (i=0; ; i++){
if (negativ_test[i].formula == NULL) {
break;
}
if (validate_load_formula(negativ_test[i].formula, &answer_list, centry_list, "load_formula") == true) {
printf("load_formula \"%s\" returned no error\n", negativ_test[i].formula);
neg_tests_failed++;
}
lFreeList(&answer_list);
}
lFreeList(¢ry_list);
lFreeElem(&host);
printf("\n");
printf("%d positiv test(s) failed\n", pos_tests_failed);
printf("%d negativ test(s) failed\n", neg_tests_failed);
DRETURN(pos_tests_failed + neg_tests_failed);
}
/**
* @param n: The Ewl_Notebook to set the tabbar position of
* @param pos: The Ewl_Position to put the tabbar in
* @return Returns no value.
* @brief Set the position of the tabbar in the notebook widget
*/
void
ewl_notebook_tabbar_position_set(Ewl_Notebook *n, Ewl_Position pos)
{
int t, pw, ph;
DENTER_FUNCTION(DLEVEL_STABLE);
DCHECK_PARAM_PTR(n);
DCHECK_TYPE(n, "notebook");
if (n->tabbar_position == pos)
DRETURN(DLEVEL_STABLE);
n->tabbar_position = pos;
switch(pos)
{
case EWL_POSITION_LEFT:
case EWL_POSITION_RIGHT:
ewl_box_orientation_set(EWL_BOX(n),
EWL_ORIENTATION_HORIZONTAL);
ewl_box_orientation_set(EWL_BOX(n->body.tabbar),
EWL_ORIENTATION_VERTICAL);
t = ewl_object_preferred_w_get(EWL_OBJECT(n->body.tabbar));
ewl_object_preferred_size_get(EWL_OBJECT(n->body.pages),
&pw, &ph);
ewl_object_preferred_inner_size_set(EWL_OBJECT(n), t + pw, ph);
break;
case EWL_POSITION_TOP:
case EWL_POSITION_BOTTOM:
default:
ewl_box_orientation_set(EWL_BOX(n),
EWL_ORIENTATION_VERTICAL);
ewl_box_orientation_set(EWL_BOX(n->body.tabbar),
EWL_ORIENTATION_HORIZONTAL);
t = ewl_object_preferred_h_get(EWL_OBJECT(n->body.tabbar));
ewl_object_preferred_size_get(EWL_OBJECT(n->body.pages),
&pw, &ph);
ewl_object_preferred_inner_size_set(EWL_OBJECT(n), pw, ph + t);
break;
}
switch (pos)
{
case EWL_POSITION_LEFT:
ewl_widget_appearance_set(n->body.tabbar, "left/tabbar");
break;
case EWL_POSITION_RIGHT:
ewl_widget_appearance_set(n->body.tabbar, "right/tabbar");
break;
case EWL_POSITION_TOP:
ewl_widget_appearance_set(n->body.tabbar, "top/tabbar");
break;
case EWL_POSITION_BOTTOM:
ewl_widget_appearance_set(n->body.tabbar, "bottom/tabbar");
break;
}
ewl_container_child_remove(EWL_CONTAINER(n), n->body.tabbar);
/* remove the redirect so we can stick the tabbar back in */
ewl_container_redirect_set(EWL_CONTAINER(n), NULL);
if ((n->tabbar_position == EWL_POSITION_RIGHT)
|| (n->tabbar_position == EWL_POSITION_BOTTOM))
ewl_container_child_append(EWL_CONTAINER(n), n->body.tabbar);
else if ((n->tabbar_position == EWL_POSITION_LEFT)
|| (n->tabbar_position == EWL_POSITION_TOP))
ewl_container_child_prepend(EWL_CONTAINER(n), n->body.tabbar);
ewl_container_redirect_set(EWL_CONTAINER(n),
EWL_CONTAINER(n->body.pages));
DLEAVE_FUNCTION(DLEVEL_STABLE);
}
int do_qhost(void *ctx, lList *host_list, lList *user_list, lList *resource_match_list,
lList *resource_list, u_long32 show, lList **alpp, qhost_report_handler_t* report_handler) {
lList *cl = NULL;
lList *ehl = NULL;
lList *ql = NULL;
lList *jl = NULL;
lList *pel = NULL;
lListElem *ep;
lCondition *where = NULL;
bool have_lists = true;
int print_header = 1;
int ret = QHOST_SUCCESS;
bool show_binding = ((show & QHOST_DISPLAY_BINDING) == QHOST_DISPLAY_BINDING) ? true : false;
#define HEAD_FORMAT_BINDING "%-23s %-13.13s%4.4s %4.4s %4.4s %5.5s %7.7s %7.7s %7.7s %7.7s\n"
#define HEAD_FORMAT "%-23s %-13.13s%4.4s %5.5s %7.7s %7.7s %7.7s %7.7s\n"
DENTER(TOP_LAYER, "do_qhost");
have_lists = get_all_lists(ctx,
alpp,
&ql,
&jl,
&cl,
&ehl,
&pel,
host_list,
user_list,
show);
if (have_lists == false) {
free_all_lists(&ql, &jl, &cl, &ehl, &pel);
DRETURN(QHOST_ERROR);
}
/*
** delete ok message
*/
lFreeList(alpp);
centry_list_init_double(cl);
/*
** handle -l request for host
*/
if (lGetNumberOfElem(resource_match_list)) {
int selected;
lListElem *global = NULL;
if (centry_list_fill_request(resource_match_list, alpp, cl, true, true, false)) {
/* TODO: error message gets written by centry_list_fill_request into SGE_EVENT */
free_all_lists(&ql, &jl, &cl, &ehl, &pel);
DRETURN(QHOST_ERROR);
}
{ /* clean host list */
lListElem *host = NULL;
for_each(host, ehl) {
lSetUlong(host, EH_tagged, 0);
}
}
/* prepare request */
global = lGetElemHost(ehl, EH_name, "global");
selected = sge_select_queue(resource_match_list, NULL, global, ehl, cl,
true, -1, NULL, NULL, NULL);
if (selected) {
for_each(ep, ehl) {
lSetUlong(ep, EH_tagged, 1);
}
} else {
/****** sge_var/var_list_parse_from_string() *******************************
* NAME
* var_list_parse_from_string() -- parse vars from string list
*
* SYNOPSIS
* int var_list_parse_from_string(lList **lpp,
* const char *variable_str,
* int check_environment)
*
* FUNCTION
* Parse a list of variables ("lpp") from a comma separated
* string list ("variable_str"). The boolean "check_environment"
* defined wether the current value of a variable is taken from
* the environment of the calling process.
*
* INPUTS
* lList **lpp - VA_Type list
* const char *variable_str - source string
* int check_environment - boolean
*
* RESULT
* int - error state
* 0 - OK
* >0 - Error
*
* NOTES
* MT-NOTE: var_list_parse_from_string() is MT safe
*******************************************************************************/
int var_list_parse_from_string(lList **lpp, const char *variable_str,
int check_environment)
{
char *variable;
char *val_str;
int var_len;
char **str_str;
char **pstr;
lListElem *ep;
char *va_string;
DENTER(TOP_LAYER, "var_list_parse_from_string");
if (!lpp) {
DEXIT;
return 1;
}
va_string = sge_strdup(NULL, variable_str);
if (!va_string) {
*lpp = NULL;
DEXIT;
return 2;
}
str_str = string_list(va_string, ",", NULL);
if (!str_str || !*str_str) {
*lpp = NULL;
sge_free(&va_string);
DEXIT;
return 3;
}
if (!*lpp) {
*lpp = lCreateList("variable list", VA_Type);
if (!*lpp) {
sge_free(&va_string);
sge_free(&str_str);
DEXIT;
return 4;
}
}
for (pstr = str_str; *pstr; pstr++) {
struct saved_vars_s *context;
ep = lCreateElem(VA_Type);
/* SGE_ASSERT(ep); */
lAppendElem(*lpp, ep);
context = NULL;
variable = sge_strtok_r(*pstr, "=", &context);
SGE_ASSERT((variable));
var_len=strlen(variable);
lSetString(ep, VA_variable, variable);
val_str=*pstr;
/*
* The character at the end of the first token must be either '=' or '\0'.
* If it's a '=' then we treat the following string as the value
* If it's a '\0' and check_environment is set, then we get the value from
* the environment variable value.
* If it's a '\0' and check_environment is not set, then we set the value
* to NULL.
*/
if (val_str[var_len] == '=') {
lSetString(ep, VA_value, &val_str[var_len+1]);
} else if (check_environment) {
lSetString(ep, VA_value, sge_getenv(variable));
} else {
lSetString(ep, VA_value, NULL);
}
sge_free_saved_vars(context);
}
sge_free(&va_string);
sge_free(&str_str);
DRETURN(0);
}