static int spawn_file(dstring *aBuffer, dstring *error_message) {
int my_errno;
char* mktemp_return = NULL;
char tmp_file_string[256];
char tmp_string[SGE_PATH_MAX];
/*
* generate template filename for mktemp()
*/
snprintf(tmp_file_string, 256, "pid-%u-XXXXXX", (unsigned int)getpid());
/*
* check final length of path
*/
if (sge_dstring_strlen(aBuffer) + strlen(tmp_file_string) >= SGE_PATH_MAX) {
sge_dstring_append(aBuffer, tmp_file_string);
sge_dstring_sprintf(error_message, MSG_TMPNAM_SGE_MAX_PATH_LENGTH_US,
sge_u32c(SGE_PATH_MAX), sge_dstring_get_string(aBuffer));
return -1;
}
/*
* now build full path string for mktemp()
*/
snprintf(tmp_string, SGE_PATH_MAX, "%s%s", sge_dstring_get_string(aBuffer), tmp_file_string);
/*
* generate temp file by call to mktemp()
*/
errno = 0;
mktemp_return = mktemp(tmp_string);
my_errno = errno;
if (mktemp_return[0] == '\0') {
sge_dstring_sprintf(error_message, MSG_TMPNAM_GOT_SYSTEM_ERROR_SS,
strerror(my_errno), sge_dstring_get_string(aBuffer));
return -1;
}
/*
* finally copy the resulting path to aBuffer
*/
sge_dstring_sprintf(aBuffer, tmp_string);
return 0;
}
/****** uti/sge_tmpnam/sge_tmpnam() *******************************************
* NAME
* sge_tmpnam() -- Secure replacement for tmpnam()
*
* SYNOPSIS
* char* sge_tmpnam(char *aBuffer)
*
* FUNCTION
* Generate a string that is a unique valid filename within a given
* directory. The corresponding file is created as soon as the filename
* has been generated, thus avoiding any delay between filename generation
* and actual file usage. The file will have read and write access for the
* user only.
*
* The 'aBuffer' argument points to an array of at least SGE_PATH_MAX length.
* 'aBuffer' will contain the generated filename upon successful completion.
* In addition, 'aBuffer' will be returned. If the function fails, NULL will
* be returned and 'errno' set to indicate the error.
*
* If the environment variable TMPDIR is defined, it's value will be used
* as the path prefix for the file. If TMPDIR is not set or it does not
* refer to a valid directory, the value of P_tmpdir will be used.
* P_tmpdir shall be defined in <stdio.h>. If P_tmpdir is not defined or
* it does not refer to a valid directory, /tmp will be used.
*
* NOTE: Since the file already exists, the O_EXCL flag must not be used if
* the returned filename is opened for usage within an application. It is,
* however, the duty of the application calling this function to delete the
* file denoted by the generated filename after it is no longer needed.
*
* INPUTS
* char *aBuffer - Array to hold filename
*
* RESULT
* char* - Points to 'aBuffer' if successful, NULL otherwise
*
* NOTE
* MT-NOTE: sge_tmpnam() is MT safe.
******************************************************************************/
char *sge_tmpnam(char *aBuffer, dstring *error_message)
{
dstring s = DSTRING_INIT;
DENTER(TOP_LAYER, "sge_tmpnam");
if (aBuffer == NULL) {
sge_dstring_sprintf(error_message, MSG_TMPNAM_GOT_NULL_PARAMETER);
DEXIT;
return NULL;
}
if (elect_path(&s) < 0) {
sge_dstring_sprintf(error_message, MSG_TMPNAM_CANNOT_GET_TMP_PATH);
sge_dstring_free(&s);
DEXIT;
return NULL;
}
if ((sge_dstring_get_string(&s))[sge_dstring_strlen(&s)-1] != '/') {
sge_dstring_append_char(&s, '/');
}
if (spawn_file(&s, error_message) < 0) {
sge_dstring_free(&s);
DEXIT;
return NULL;
}
sge_strlcpy(aBuffer, sge_dstring_get_string(&s), SGE_PATH_MAX);
sge_dstring_free(&s);
DPRINTF(("sge_tmpnam: returning %s\n", aBuffer));
DEXIT;
return aBuffer;
}
/****** category/sge_build_job_category_dstring() ******************************
* NAME
* sge_build_job_category_dstring() -- build the category string
*
* SYNOPSIS
* void sge_build_job_category_dstring(dstring *category_str, lListElem
* *job, lList *acl_list)
*
* FUNCTION
* The following parameter are put into the category:
* hard_queue_list
* master_hard_queue_list
* hard_resource_list
* soft_resource_list
* checkpoint_name
* type
*
* owner/group: -U user_lists
* Omitted, if user_lists/xuser_lists were not used in
* host_conf(5), sge_pe(5) and queue_conf(5). In sge_conf(5)
* user_lists/xuser_lists still can be used, as it causes
* jobs already be rejected at submit time.
*
* project: -P user_lists
* Omitted, if projects/xprojects were not used in
* host_conf(5), sge_pe(5) and queue_conf(5). In sge_conf(5)
* projects/xprojects still can be used, as it cuases
* jobs already be rejected at submit time.
*
* pe
*
* INPUTS
* dstring *category_str - target string, contains the category or nothing
* lListElem *job - the job for the category creating
* lList *acl_list - global access list
*
* NOTES
* MT-NOTE: sge_build_job_category_dstring() is MT safe as long as the caller is
*
*******************************************************************************/
void sge_build_job_category_dstring(dstring *category_str, lListElem *job, lList *acl_list, const lList *prj_list, bool *did_project, const lList *rqs_list)
{
const char *owner = NULL;
const char *group = NULL;
DENTER(TOP_LAYER, "sge_build_job_category_dstring");
DTRACE;
#if 0
sge_mutex_lock("cull_order_mutex", SGE_FUNC, __LINE__, &Category_Control.cull_order_mutex);
if (Category_Control.cull_order_pos.JB_hard_queue_list_pos == -1) {
Category_Control.cull_order_pos.JB_checkpoint_name_pos = lGetPosViaElem(job, JB_checkpoint_name, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_soft_resource_list_pos = lGetPosViaElem(job, JB_soft_resource_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_master_hard_queue_list_pos = lGetPosViaElem(job, JB_master_hard_queue_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_hard_queue_list_pos = lGetPosViaElem(job, JB_hard_queue_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_owner_pos = lGetPosViaElem(job, JB_owner, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_group_pos = lGetPosViaElem(job, JB_group, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_hard_resource_list_pos = lGetPosViaElem(job, JB_hard_resource_list, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_type_pos = lGetPosViaElem(job, JB_type, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_project_pos = lGetPosViaElem(job, JB_project, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_ar_pos = lGetPosViaElem(job, JB_ar, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_pe_pos = lGetPosViaElem(job, JB_pe, SGE_NO_ABORT);
Category_Control.cull_order_pos.JB_range_pos = lGetPosViaElem(job, JB_pe_range, SGE_NO_ABORT);
}
sge_mutex_unlock("cull_order_mutex", SGE_FUNC, __LINE__, &Category_Control.cull_order_mutex);
#endif
DTRACE;
/*
** owner -> acl
*/
owner = lGetPosString(job, lGetPosViaElem(job, JB_owner, SGE_NO_ABORT));
DTRACE;
group = lGetPosString(job, lGetPosViaElem(job, JB_group, SGE_NO_ABORT));
DTRACE;
sge_unparse_acl_dstring(category_str, owner, group, acl_list, "-U");
DTRACE;
/*
** -u if referenced in resource quota sets
*/
/* RD TODO: A possible performance enhancement is to split user and group inside category.
Some users are only referenced by the unix group. Their jobs could be grouped
together by referencing only the group in the category string
*/
if (sge_user_is_referenced_in_rqs(rqs_list, lGetString(job, JB_owner), lGetString(job, JB_group), acl_list)) {
if (sge_dstring_strlen(category_str) > 0) {
sge_dstring_append(category_str, " ");
}
sge_dstring_append(category_str, "-u ");
sge_dstring_append(category_str, lGetString(job, JB_owner));
}
DTRACE;
/*
** -hard -q qlist
*/
sge_unparse_queue_list_dstring(category_str, job, lGetPosViaElem(job, JB_hard_queue_list, SGE_NO_ABORT), "-q");
DTRACE;
/*
** -masterq qlist
*/
sge_unparse_queue_list_dstring(category_str, job, lGetPosViaElem(job, JB_master_hard_queue_list, SGE_NO_ABORT), "-masterq");
DTRACE;
/*
** -l rlist (hard resource list)
*/
sge_unparse_resource_list_dstring(category_str, job, lGetPosViaElem(job, JB_hard_resource_list, SGE_NO_ABORT), "-l");
DTRACE;
/*
** -soft -l rlist
*/
sge_unparse_resource_list_dstring(category_str, job, lGetPosViaElem(job, JB_soft_resource_list, SGE_NO_ABORT), "-soft -l");
DTRACE;
/*
** -pe pe_name pe_range
*/
sge_unparse_pe_dstring(category_str, job, lGetPosViaElem(job, JB_pe, SGE_NO_ABORT),
lGetPosViaElem(job, JB_pe_range, SGE_NO_ABORT), "-pe");
DTRACE;
/*
** -ckpt ckpt_name
*/
sge_unparse_string_option_dstring(category_str, job, lGetPosViaElem(job, JB_checkpoint_name, SGE_NO_ABORT), "-ckpt");
DTRACE;
/*
** interactive jobs
*/
if (JOB_TYPE_IS_IMMEDIATE(lGetPosUlong(job, lGetPosViaElem(job, JB_type, SGE_NO_ABORT)))) {
if (sge_dstring_strlen(category_str) > 0) {
sge_dstring_append(category_str, " -I y");
}
else {
sge_dstring_append(category_str, "-I y");
}
}
DTRACE;
/*
** project
*/
{
const char *project = lGetPosString(job, lGetPosViaElem(job, JB_project, SGE_NO_ABORT));
const lListElem *prj;
if (project && (prj=lGetElemStr(prj_list, PR_name, project)) && lGetBool(prj, PR_consider_with_categories)) {
if (did_project)
*did_project = true;
sge_unparse_string_option_dstring(category_str, job, lGetPosViaElem(job, JB_project, SGE_NO_ABORT), "-P");
} else
if (did_project)
*did_project = false;
}
DTRACE;
/*
** -ar ar_id
*/
sge_unparse_ulong_option_dstring(category_str, job, lGetPosViaElem(job, JB_ar, SGE_NO_ABORT), "-ar");
DRETURN_VOID;
}
static bool
check_all(dstring *sb)
{
bool ret = true;
int i;
/* sge_dstring_append */
printf("\nchecking sge_dstring_append\n");
sge_dstring_append(NULL, NULL);
sge_dstring_append(sb, NULL);
check_dstring(sb);
sge_dstring_append(sb, "blah");
check_dstring(sb);
sge_dstring_clear(sb);
sge_dstring_append(sb, "too long string to fit into a static string buffer");
check_dstring(sb);
sge_dstring_clear(sb);
sge_dstring_append(sb,
"long string that requires multiple chunks ....... ");
check_dstring(sb);
for (i = 0; i < 20; i++) {
sge_dstring_append(sb,
"long string that requires multiple chunks ....... ");
}
check_dstring(sb);
/* sge_dstring_append_dstring */
printf("\nchecking sge_dstring_append_dstring\n");
sge_dstring_clear(sb);
sge_dstring_append_dstring(NULL, NULL);
{
dstring second = DSTRING_INIT;
sge_dstring_append(&second, "dstring");
sge_dstring_append_dstring(NULL, &second);
sge_dstring_append_dstring(sb, NULL);
sge_dstring_append_dstring(sb, &second);
check_dstring(sb);
sge_dstring_free(&second);
}
/* sge_dstring_append_char */
printf("\nchecking sge_dstring_append_char\n");
sge_dstring_clear(sb);
sge_dstring_append_char(NULL, 'a');
sge_dstring_append_char(sb, '\0');
check_dstring(sb);
sge_dstring_append_char(sb, 'a');
check_dstring(sb);
sge_dstring_append_char(sb, 'b');
check_dstring(sb);
/* sge_dstring_sprintf */
printf("\nchecking sge_dstring_sprintf\n");
sge_dstring_sprintf(NULL, "test %s", "string");
sge_dstring_sprintf(sb, NULL);
sge_dstring_sprintf(sb, "test %s", "string");
check_dstring(sb);
#if 0
/* does not build on irix */
/* sge_dstring_vsprintf */
printf("\nchecking sge_dstring_vsprintf\n");
{
const char *args[] = { "string", NULL };
sge_dstring_clear(sb);
sge_dstring_vsprintf(NULL, "test %s", args);
sge_dstring_vsprintf(sb, NULL, args);
sge_dstring_vsprintf(sb, "test %s", args);
check_dstring(sb);
}
#endif
/* sge_dstring_sprintf_append */
printf("\nchecking sge_dstring_sprintf_append\n");
sge_dstring_clear(sb);
sge_dstring_sprintf_append(NULL, "test %s", "string");
sge_dstring_sprintf_append(sb, NULL);
sge_dstring_sprintf_append(sb, "test %s", "string");
sge_dstring_sprintf_append(sb, " appended test %s", "string");
check_dstring(sb);
/* sge_dstring_clear */
printf("\nchecking sge_dstring_clear\n");
sge_dstring_clear(NULL);
sge_dstring_clear(sb);
check_dstring(sb);
/* sge_dstring_free */
printf("\nchecking sge_dstring_free\n");
sge_dstring_free(NULL);
sge_dstring_free(sb);
check_dstring(sb);
/* sge_dstring_get_string */
printf("\nchecking sge_dstring_get_string\n");
sge_dstring_clear(sb);
sge_dstring_append(sb, "test string");
{
const char *result;
result = sge_dstring_get_string(NULL);
printf("sge_dstring_get_string(NULL) = %s\n",
result == NULL ? "NULL" : result);
result = sge_dstring_get_string(sb);
printf("sge_dstring_get_string(sb) = %s\n",
result == NULL ? "NULL" : result);
}
/* sge_dstring_copy_string */
printf("\nchecking sge_dstring_copy_string\n");
sge_dstring_copy_string(NULL, NULL);
sge_dstring_copy_string(sb, NULL);
sge_dstring_copy_string(NULL, "new test string");
sge_dstring_copy_string(sb, "new test string");
check_dstring(sb);
/* sge_dstring_copy_dstring
* check only NULL pointer behaviour, it just calls sge_dstring_copy_string
*/
printf("\nchecking sge_dstring_copy_dstring\n");
sge_dstring_copy_dstring(NULL, NULL);
sge_dstring_copy_dstring(sb, NULL);
check_dstring(sb);
/* sge_dstring_strlen */
printf("\nchecking sge_dstring_strlen\n");
{
int len;
sge_dstring_copy_string(sb, "test string");
len = sge_dstring_strlen(NULL);
printf("sge_dstring_strlen(NULL) = %d\n", len);
len = sge_dstring_strlen(sb);
printf("sge_dstring_strlen(sb) = %d\n", len);
}
/* sge_dstring_remaining */
printf("\nchecking sge_dstring_remaining\n");
{
int len;
sge_dstring_copy_string(sb, "test string");
len = sge_dstring_remaining(NULL);
printf("sge_dstring_remaining(NULL) = %d\n", len);
len = sge_dstring_remaining(sb);
printf("sge_dstring_remaining(sb) = %d\n", len);
}
return ret;
}
