/**
* Is the user a real user account?
* Checks:
* 1. Not root
* 2. UID is above the minimum configured.
* 3. Not in banned user list
* Returns NULL on failure
*/
struct passwd* check_user(const char *user) {
if (strcmp(user, "root") == 0) {
fprintf(LOGFILE, "Running as root is not allowed\n");
fflush(LOGFILE);
return NULL;
}
char *min_uid_str = get_value(MIN_USERID_KEY);
int min_uid = DEFAULT_MIN_USERID;
if (min_uid_str != NULL) {
char *end_ptr = NULL;
min_uid = strtol(min_uid_str, &end_ptr, 10);
if (min_uid_str == end_ptr || *end_ptr != '\0') {
fprintf(LOGFILE, "Illegal value of %s for %s in configuration\n",
min_uid_str, MIN_USERID_KEY);
fflush(LOGFILE);
free(min_uid_str);
min_uid_str = NULL;
return NULL;
}
free(min_uid_str);
min_uid_str = NULL;
}
struct passwd *user_info = get_user_info(user);
if (NULL == user_info) {
fprintf(LOGFILE, "User %s not found\n", user);
fflush(LOGFILE);
return NULL;
}
if (user_info->pw_uid < min_uid) {
fprintf(LOGFILE, "Requested user %s has id %d, which is below the "
"minimum allowed %d\n", user, user_info->pw_uid, min_uid);
fflush(LOGFILE);
free(user_info);
user_info = NULL;
return NULL;
}
char **banned_users = get_values(BANNED_USERS_KEY);
char **banned_user = (banned_users == NULL) ?
(char**) DEFAULT_BANNED_USERS : banned_users;
for(; *banned_user; ++banned_user) {
if (strcmp(*banned_user, user) == 0) {
free(user_info);
user_info = NULL;
if (banned_users != (char**)DEFAULT_BANNED_USERS) {
free_values(banned_users);
banned_users = NULL;
}
fprintf(LOGFILE, "Requested user %s is banned\n", user);
return NULL;
}
}
if (banned_users != NULL && banned_users != (char**)DEFAULT_BANNED_USERS) {
free_values(banned_users);
banned_users = NULL;
}
return user_info;
}
/**
* Function to prepare the attempt directories for the task JVM.
* It creates the task work and log directories.
*/
static int create_attempt_directories(const char* user, const char *job_id,
const char *task_id) {
// create dirs as 0750
const mode_t perms = S_IRWXU | S_IRGRP | S_IXGRP;
if (job_id == NULL || task_id == NULL || user == NULL) {
fprintf(LOGFILE,
"Either task_id is null or the user passed is null.\n");
return -1;
}
int result = 0;
char **local_dir = get_values(TT_SYS_DIR_KEY);
if (local_dir == NULL) {
fprintf(LOGFILE, "%s is not configured.\n", TT_SYS_DIR_KEY);
return -1;
}
char **local_dir_ptr;
for(local_dir_ptr = local_dir; *local_dir_ptr != NULL; ++local_dir_ptr) {
char *task_dir = get_attempt_work_directory(*local_dir_ptr, user, job_id,
task_id);
if (task_dir == NULL) {
free_values(local_dir);
return -1;
}
if (mkdirs(task_dir, perms) != 0) {
// continue on to create other task directories
free(task_dir);
} else {
free(task_dir);
}
}
free_values(local_dir);
// also make the directory for the task logs
char *job_task_name = malloc(strlen(job_id) + strlen(task_id) + 2);
if (job_task_name == NULL) {
fprintf(LOGFILE, "Malloc of job task name failed\n");
result = -1;
} else {
sprintf(job_task_name, "%s/%s", job_id, task_id);
char *log_dir = get_job_log_directory(job_task_name);
free(job_task_name);
if (log_dir == NULL) {
result = -1;
} else if (mkdirs(log_dir, perms) != 0) {
result = -1;
}
free(log_dir);
}
return result;
}
int is_whitelisted(const char *user) {
char **whitelist = get_values(ALLOWED_SYSTEM_USERS_KEY);
char **users = whitelist;
if (whitelist != NULL) {
for(; *users; ++users) {
if (strncmp(*users, user, LOGIN_NAME_MAX) == 0) {
free_values(whitelist);
return 1;
}
}
free_values(whitelist);
}
return 0;
}
/**
* Function to initialize the user directories of a user.
*/
int initialize_user(const char *user, const char * good_local_dirs) {
char **local_dir = get_mapred_local_dirs(good_local_dirs);
if (local_dir == NULL) {
fprintf(LOGFILE, "Good mapred local directories could ot be obtained.\n");
return INVALID_TT_ROOT;
}
char *user_dir;
char **local_dir_ptr = local_dir;
int failed = 0;
for(local_dir_ptr = local_dir; *local_dir_ptr != 0; ++local_dir_ptr) {
user_dir = get_user_directory(*local_dir_ptr, user);
if (user_dir == NULL) {
fprintf(LOGFILE, "Couldn't get userdir directory for %s.\n", user);
failed = 1;
break;
}
if (create_directory_for_user(user_dir) != 0) {
failed = 1;
}
free(user_dir);
}
free_values(local_dir);
return failed ? INITIALIZE_USER_FAILED : 0;
}
/**
* Delete the given directory as the user from each of the tt_root directories
* user: the user doing the delete
* subdir: the subdir to delete
*/
int delete_as_user(const char *user, const char * good_local_dirs,
const char *subdir) {
int ret = 0;
char** tt_roots = get_mapred_local_dirs(good_local_dirs);
char** ptr;
if (tt_roots == NULL || *tt_roots == NULL) {
fprintf(LOGFILE, "Good mapred local directories could ot be obtained.\n");
return INVALID_TT_ROOT;
}
// do the delete
for(ptr = tt_roots; *ptr != NULL; ++ptr) {
char* full_path = get_user_subdirectory(*ptr, user, subdir);
if (full_path == NULL) {
return -1;
}
int this_ret = delete_path(full_path, strlen(subdir) == 0);
free(full_path);
// delete as much as we can, but remember the error
if (this_ret != 0) {
ret = this_ret;
}
}
free_values(tt_roots);
return ret;
}
/**
* Delete the given directory as the user from each of the tt_root directories
* user: the user doing the delete
* subdir: the subdir to delete
*/
int delete_as_user(const char *user,
const char *subdir) {
int ret = 0;
char** tt_roots = get_values(TT_SYS_DIR_KEY);
char** ptr;
if (tt_roots == NULL || *tt_roots == NULL) {
fprintf(LOGFILE, "No %s defined in the configuration\n", TT_SYS_DIR_KEY);
return INVALID_CONFIG_FILE;
}
// do the delete
for(ptr = tt_roots; *ptr != NULL; ++ptr) {
char* full_path = get_user_subdirectory(*ptr, user, subdir);
if (full_path == NULL) {
return -1;
}
int this_ret = delete_path(full_path, strlen(subdir) == 0);
free(full_path);
// delete as much as we can, but remember the error
if (this_ret != 0) {
ret = this_ret;
}
}
free_values(tt_roots);
return ret;
}
/**
* Function to initialize the user directories of a user.
*/
int initialize_user(const char *user) {
char **local_dir = get_values(TT_SYS_DIR_KEY);
if (local_dir == NULL) {
fprintf(LOGFILE, "%s is not configured.\n", TT_SYS_DIR_KEY);
return INVALID_TT_ROOT;
}
char *user_dir;
char **local_dir_ptr = local_dir;
int failed = 0;
for(local_dir_ptr = local_dir; *local_dir_ptr != 0; ++local_dir_ptr) {
user_dir = get_user_directory(*local_dir_ptr, user);
if (user_dir == NULL) {
fprintf(LOGFILE, "Couldn't get userdir directory for %s.\n", user);
failed = 1;
break;
}
if (create_directory_for_user(user_dir) != 0) {
failed = 1;
}
free(user_dir);
}
free_values(local_dir);
return failed ? INITIALIZE_USER_FAILED : 0;
}
/*
* delete a given job log directory
* This function takes jobid and deletes the related logs.
*/
int delete_log_directory(const char *subdir, const char * good_local_dirs) {
char* job_log_dir = get_job_log_directory(subdir);
int ret = -1;
if (job_log_dir == NULL) return ret;
//delete the job log directory in <hadoop.log.dir>/userlogs/jobid
delete_path(job_log_dir, true);
char **local_dir = get_mapred_local_dirs(good_local_dirs);
char **local_dir_ptr;
for(local_dir_ptr = local_dir; *local_dir_ptr != NULL; ++local_dir_ptr) {
char *mapred_local_log_dir = concatenate("%s/userlogs/%s",
"mapred local job log dir",
2, *local_dir_ptr, subdir);
if (mapred_local_log_dir != NULL) {
//delete the job log directory in <mapred.local.dir>/userlogs/jobid
delete_path(mapred_local_log_dir, true);
free(mapred_local_log_dir);
}
else
fprintf(LOGFILE, "Failed to delete mapred local log dir for jobid %s\n",
subdir);
}
free(job_log_dir);
free_values(local_dir);
return 0;
}
int
heim_digest_parse_response(heim_digest_t context, const char *response)
{
struct md5_value *val = NULL;
char *nonce;
int ret;
ret = parse_values(response, &val);
if (ret)
goto out;
ret = 1;
if (context->type == HEIM_DIGEST_TYPE_AUTO)
goto out;
context->clientUsername = values_find(&val, "username");
if (context->clientUsername == NULL) goto out;
context->clientRealm = values_find(&val, "realm");
context->clientResponse = values_find(&val, "response");
if (context->clientResponse == NULL) goto out;
nonce = values_find(&val, "nonce");
if (nonce == NULL) goto out;
if (strcmp(nonce, context->serverNonce) != 0) {
free(nonce);
goto out;
}
free(nonce);
context->clientQOP = values_find(&val, "qop");
if (context->clientQOP == NULL)
context->clientQOP = strdup("auth");
if (context->clientQOP == NULL) goto out;
if (context->type != HEIM_DIGEST_TYPE_RFC2069) {
context->clientNC = values_find(&val, "nc");
if (context->clientNC == NULL) goto out;
context->clientNonce = values_find(&val, "cnonce");
if (context->clientNonce == NULL) goto out;
}
if (context->type == HEIM_DIGEST_TYPE_RFC2069)
context->clientURI = values_find(&val, "uri");
else
context->clientURI = values_find(&val, "digest-uri");
if (context->clientURI == NULL) goto out;
ret = 0;
out:
free_values(val);
return ret;
}
void create_userlogs_dir() {
char** tt_roots = get_values("mapred.local.dir");
char** tt_root;
for(tt_root=tt_roots; *tt_root != NULL; ++tt_root) {
char buffer[100000];
sprintf(buffer, "%s/userlogs", *tt_root);
if (mkdir(buffer, 0755) != 0) {
printf("FAIL: Can't create directory %s - %s\n", buffer,
strerror(errno));
exit(1);
}
}
free_values(tt_roots);
}
int
heim_digest_parse_challenge(heim_digest_t context, const char *challenge)
{
struct md5_value *val = NULL;
int ret, type;
challenge = check_prefix(context, challenge);
ret = parse_values(challenge, &val);
if (ret)
goto out;
ret = 1;
context->serverNonce = values_find(&val, "nonce");
if (context->serverNonce == NULL) goto out;
context->serverRealm = values_find(&val, "realm");
if (context->serverRealm == NULL) goto out;
/* check alg */
context->serverAlgorithm = values_find(&val, "algorithm");
if (context->serverAlgorithm == NULL || strcasecmp(context->serverAlgorithm, "md5") == 0) {
type = HEIM_DIGEST_TYPE_RFC2617_MD5;
} else if (strcasecmp(context->serverAlgorithm, "md5-sess") == 0) {
type = HEIM_DIGEST_TYPE_RFC2617_OR_RFC2831;
} else {
goto out;
}
context->serverQOP = values_find(&val, "qop");
if (context->serverQOP == NULL)
type = HEIM_DIGEST_TYPE_RFC2069;
context->serverOpaque = values_find(&val, "opaque");
if (context->type != HEIM_DIGEST_TYPE_AUTO && (context->type & type) == 0)
goto out;
else if (context->type == HEIM_DIGEST_TYPE_AUTO)
context->type = type;
ret = 0;
out:
free_values(val);
if (ret)
clear_context(context);
return ret;
}
static void
mem_handle_destroy (GslDataHandle *dhandle)
{
MemHandle *mhandle = (MemHandle*) dhandle;
void (*free_values) (gpointer) = mhandle->free_values;
const gfloat *mem_values = mhandle->values;
gsl_data_handle_common_free (dhandle);
mhandle->values = NULL;
mhandle->free_values = NULL;
gsl_delete_struct (MemHandle, mhandle);
if (free_values)
free_values ((gpointer) mem_values);
}
int
heim_digest_parse_challenge(heim_digest_t context, const char *challenge)
{
struct md5_value *val = NULL;
int ret, type;
ret = parse_values(challenge, &val);
if (ret)
goto out;
ret = 1;
context->serverNonce = values_find(&val, "nonce");
if (context->serverNonce == NULL) goto out;
context->serverRealm = values_find(&val, "realm");
if (context->serverRealm == NULL) goto out;
context->serverQOP = values_find(&val, "qop");
if (context->serverQOP == NULL)
context->serverQOP = strdup("auth");
if (context->serverQOP == NULL) goto out;
/* check alg */
context->serverAlgorithm = values_find(&val, "algorithm");
if (context->serverAlgorithm == NULL || strcasecmp(context->serverAlgorithm, "md5") == 0) {
type = HEIM_DIGEST_TYPE_RFC2069;
} else if (strcasecmp(context->serverAlgorithm, "md5-sess") == 0) {
type = HEIM_DIGEST_TYPE_MD5_SESS;
} else {
goto out;
}
if (context->type != HEIM_DIGEST_TYPE_AUTO && context->type != type)
goto out;
else
context->type = type;
ret = 0;
out:
free_values(val);
if (ret)
clear_context(context);
return ret;
}
static void
insert_handle_destroy (GslDataHandle *data_handle)
{
InsertHandle *ihandle = (InsertHandle*) data_handle;
void (*free_values) (gpointer) = ihandle->free_values;
const gfloat *paste_values = ihandle->paste_values;
gsl_data_handle_unref (ihandle->src_handle);
gsl_data_handle_common_free (data_handle);
ihandle->paste_values = NULL;
ihandle->free_values = NULL;
gsl_delete_struct (InsertHandle, ihandle);
if (free_values)
free_values ((gpointer) paste_values);
}
int
prep_row(MdbTableDef *table, char *line, MdbField *fields, char *delim)
{
MdbColumn *col;
char **sarray, *s;
unsigned int i;
/*
* pull apart the row and turn it into something respectable
*/
g_strdelimit(line, delim, '\n');
sarray = g_strsplit (line, "\n", 0);
for (i=0; (s = sarray[i]); i++) {
if (!strlen(s)) continue;
if (i >= table->num_cols) {
fprintf(stderr, "Number of columns in file exceeds number in table.\n");
g_strfreev(sarray);
return 0;
}
if (s[0]=='"' && s[strlen(s)-1]=='"') {
s[strlen(s)-1] = '\0';
memmove(s+1, s, strlen(s));
}
printf("field = %s\n", s);
col = g_ptr_array_index (table->columns, i);
if (convert_field(col, s, &fields[i])) {
fprintf(stderr, "Format error in column %d\n", i+1);
g_strfreev(sarray);
return 0;
}
}
g_strfreev(sarray);
/*
* verify number of columns in table against number in row
*/
if (i < table->num_cols) {
fprintf(stderr, "Row has %d columns, but table has %d\n", i, table->num_cols);
free_values(fields, i);
return 0;
}
return i-1;
}
void create_nm_roots() {
char** nm_roots = get_values(NM_SYS_DIR_KEY);
char** nm_root;
for(nm_root=nm_roots; *nm_root != NULL; ++nm_root) {
if (mkdir(*nm_root, 0755) != 0) {
printf("FAIL: Can't create directory %s - %s\n", *nm_root,
strerror(errno));
exit(1);
}
char buffer[100000];
sprintf(buffer, "%s/usercache", *nm_root);
if (mkdir(buffer, 0755) != 0) {
printf("FAIL: Can't create directory %s - %s\n", buffer,
strerror(errno));
exit(1);
}
}
free_values(nm_roots);
}
/**
* Function to prepare the attempt directories for the task JVM.
* It creates the task work and log directories.
*/
int create_attempt_directories(const char* user,
const char * good_local_dirs, const char *job_id, const char *task_id) {
// create dirs as 0750
const mode_t perms = S_IRWXU | S_IRGRP | S_IXGRP;
if (job_id == NULL || task_id == NULL || user == NULL) {
fprintf(LOGFILE,
"Either task_id is null or the user passed is null.\n");
return -1;
}
int result = 0;
char **local_dir = get_mapred_local_dirs(good_local_dirs);
if (local_dir == NULL) {
fprintf(LOGFILE, "Good mapred local directories could not be obtained.\n");
return INVALID_TT_ROOT;
}
char **local_dir_ptr;
for(local_dir_ptr = local_dir; *local_dir_ptr != NULL; ++local_dir_ptr) {
char *task_dir = get_attempt_work_directory(*local_dir_ptr, user, job_id,
task_id);
if (task_dir == NULL) {
free_values(local_dir);
return -1;
}
if (mkdirs(task_dir, perms) != 0) {
// continue on to create other task directories
free(task_dir);
} else {
free(task_dir);
}
}
// also make the directory for the task logs
char *job_task_name = malloc(strlen(job_id) + strlen(task_id) + 2);
char *real_task_dir = NULL; // target of symlink
char *real_job_dir = NULL; // parent dir of target of symlink
char *random_local_dir = NULL;
char *link_task_log_dir = NULL; // symlink
if (job_task_name == NULL) {
fprintf(LOGFILE, "Malloc of job task name failed\n");
result = -1;
} else {
sprintf(job_task_name, "%s/%s", job_id, task_id);
link_task_log_dir = get_job_log_directory(job_task_name);
random_local_dir = get_random_local_dir(local_dir);
if(random_local_dir == NULL) {
result = -1;
goto cleanup;
}
real_job_dir = malloc(strlen(random_local_dir) + strlen(USERLOGS) +
strlen(job_id) + 3);
if (real_job_dir == NULL) {
fprintf(LOGFILE, "Malloc of real job directory failed\n");
result = -1;
goto cleanup;
}
real_task_dir = malloc(strlen(random_local_dir) + strlen(USERLOGS) +
strlen(job_id) + strlen(task_id) + 4);
if (real_task_dir == NULL) {
fprintf(LOGFILE, "Malloc of real task directory failed\n");
result = -1;
goto cleanup;
}
sprintf(real_job_dir, "%s/userlogs/%s", random_local_dir, job_id);
result = create_directory_for_user(real_job_dir);
if( result != 0) {
result = -1;
goto cleanup;
}
sprintf(real_task_dir, "%s/userlogs/%s/%s",
random_local_dir, job_id, task_id);
result = mkdirs(real_task_dir, perms);
if( result != 0) {
result = -1;
goto cleanup;
}
result = symlink(real_task_dir, link_task_log_dir);
if( result != 0) {
fprintf(LOGFILE, "Failed to create symlink %s to %s - %s\n",
link_task_log_dir, real_task_dir, strerror(errno));
result = -1;
}
}
cleanup:
free(random_local_dir);
free(job_task_name);
free(link_task_log_dir);
free(real_job_dir);
free(real_task_dir);
free_values(local_dir);
return result;
}
int
heim_digest_parse_response(heim_digest_t context, const char *response)
{
struct md5_value *val = NULL;
char *nonce;
int ret;
response = check_prefix(context, response);
ret = parse_values(response, &val);
if (ret)
goto out;
ret = 1;
if (context->type == HEIM_DIGEST_TYPE_AUTO) {
goto out;
} else if (context->type == HEIM_DIGEST_TYPE_RFC2617_OR_RFC2831) {
context->clientURI = values_find(&val, "uri");
if (context->clientURI) {
context->type = HEIM_DIGEST_TYPE_RFC2617_MD5_SESS;
} else {
context->clientURI = values_find(&val, "digest-uri");
context->type = HEIM_DIGEST_TYPE_RFC2831;
}
} else if (context->type == HEIM_DIGEST_TYPE_RFC2831) {
context->clientURI = values_find(&val, "digest-uri");
} else {
context->clientURI = values_find(&val, "uri");
}
if (context->clientURI == NULL)
goto out;
context->clientUsername = values_find(&val, "username");
if (context->clientUsername == NULL) goto out;
/* if client sent realm, make sure its the same of serverRealm if its set */
context->clientRealm = values_find(&val, "realm");
if (context->clientRealm && context->serverRealm && strcmp(context->clientRealm, context->serverRealm) != 0)
goto out;
context->clientResponse = values_find(&val, "response");
if (context->clientResponse == NULL) goto out;
nonce = values_find(&val, "nonce");
if (nonce == NULL) goto out;
if (strcmp(nonce, context->serverNonce) != 0) {
free(nonce);
goto out;
}
free(nonce);
if (context->type != HEIM_DIGEST_TYPE_RFC2069) {
context->clientQOP = values_find(&val, "qop");
if (context->clientQOP == NULL) goto out;
/*
* If we have serverQOP, lets check that clientQOP exists
* in the list of server entries.
*/
if (context->serverQOP) {
Boolean found = false;
char *b, *e;
size_t len, clen = strlen(context->clientQOP);
b = context->serverQOP;
while (b && !found) {
e = strchr(b, ',');
if (e == NULL)
len = strlen(b);
else {
len = e - b;
e += 1;
}
if (clen == len && strncmp(b, context->clientQOP, len) == 0)
found = true;
b = e;
}
if (!found)
goto out;
}
context->clientNC = values_find(&val, "nc");
if (context->clientNC == NULL) goto out;
context->clientNonce = values_find(&val, "cnonce");
if (context->clientNonce == NULL) goto out;
}
set_auth_method(context);
ret = 0;
out:
free_values(val);
return ret;
}
static int
parse_values(const char *string, struct md5_value **val)
{
struct md5_value *v;
size_t size;
char *str, *p1, *p2;
size_t sz;
*val = NULL;
if ((str = strdup(string)) == NULL)
return ENOMEM;
size = strlen(str);
p1 = str;
while (p1 - str < size) {
sz = strspn(p1, " \t\n\r,");
if (p1[sz] == '\0')
break;
p1 += sz;
sz = strcspn(p1, " \t\n\r=");
if (sz == 0 || p1[sz] == '\0')
goto error;
p2 = p1 + sz;
if ((v = malloc(sizeof(*v))) == NULL)
goto nomem;
v->mv_name = v->mv_value = NULL;
v->mv_next = *val;
*val = v;
if ((v->mv_name = malloc(p2 - p1 + 1)) == NULL)
goto nomem;
strncpy(v->mv_name, p1, p2 - p1);
v->mv_name[p2 - p1] = '\0';
sz = strspn(p2, " \t\n\r");
if (p2[sz] == '\0')
goto error;
p2 += sz;
if (*p2 != '=')
goto error;
p2++;
sz = strspn(p2, " \t\n\r");
if (p2[sz] == '\0')
goto error;
p2 += sz;
p1 = p2;
if (*p2 == '"') {
p1++;
while (*p2 == '"') {
p2++;
p2 = strchr(p2, '\"');
if (p2 == NULL)
goto error;
if (p2[0] == '\0')
goto error;
if (p2[-1] != '\\')
break;
}
} else {
sz = strcspn(p2, " \t\n\r=,");
p2 += sz;
}
#if 0 /* allow empty values */
if (p1 == p2)
goto error;
#endif
if ((v->mv_value = malloc(p2 - p1 + 1)) == NULL)
goto nomem;
strncpy(v->mv_value, p1, p2 - p1);
v->mv_value[p2 - p1] = '\0';
if (p2[0] == '\0')
break;
if (p2[0] == '"')
p2++;
sz = strspn(p2, " \t\n\r");
if (p2[sz] == '\0')
break;
p2 += sz;
if (p2[0] == '\0')
break;
if (p2[0] != ',')
goto error;
p1 = p2;
}
free(str);
return 0;
error:
free_values(*val);
*val = NULL;
free(str);
return EINVAL;
nomem:
free_values(*val);
*val = NULL;
free(str);
return ENOMEM;
}
/**
* Function to prepare the container directories.
* It creates the container work and log directories.
*/
static int create_container_directories(const char* user, const char *app_id,
const char *container_id) {
// create dirs as 0750
const mode_t perms = S_IRWXU | S_IRGRP | S_IXGRP;
if (app_id == NULL || container_id == NULL || user == NULL) {
fprintf(LOGFILE,
"Either app_id, container_id or the user passed is null.\n");
return -1;
}
int result = -1;
char **local_dir = get_values(NM_SYS_DIR_KEY);
if (local_dir == NULL) {
fprintf(LOGFILE, "%s is not configured.\n", NM_SYS_DIR_KEY);
return -1;
}
char **local_dir_ptr;
for(local_dir_ptr = local_dir; *local_dir_ptr != NULL; ++local_dir_ptr) {
char *container_dir = get_container_work_directory(*local_dir_ptr, user, app_id,
container_id);
if (container_dir == NULL) {
free_values(local_dir);
return -1;
}
if (mkdirs(container_dir, perms) == 0) {
result = 0;
}
// continue on to create other work directories
free(container_dir);
}
free_values(local_dir);
if (result != 0) {
return result;
}
result = -1;
// also make the directory for the container logs
char *combined_name = malloc(strlen(app_id) + strlen(container_id) + 2);
if (combined_name == NULL) {
fprintf(LOGFILE, "Malloc of combined name failed\n");
result = -1;
} else {
sprintf(combined_name, "%s/%s", app_id, container_id);
char **log_dir = get_values(NM_LOG_DIR_KEY);
if (log_dir == NULL) {
free(combined_name);
fprintf(LOGFILE, "%s is not configured.\n", NM_LOG_DIR_KEY);
return -1;
}
char **log_dir_ptr;
for(log_dir_ptr = log_dir; *log_dir_ptr != NULL; ++log_dir_ptr) {
char *container_log_dir = get_app_log_directory(*log_dir_ptr, combined_name);
if (container_log_dir == NULL) {
free(combined_name);
free_values(log_dir);
return -1;
} else if (mkdirs(container_log_dir, perms) != 0) {
free(container_log_dir);
} else {
result = 0;
free(container_log_dir);
}
}
free(combined_name);
free_values(log_dir);
}
return result;
}
/**
* Function to prepare the job directories for the task JVM.
*/
int initialize_job(const char *user, const char *jobid,
const char* credentials, const char* job_xml,
char* const* args) {
if (jobid == NULL || user == NULL) {
fprintf(LOGFILE, "Either jobid is null or the user passed is null.\n");
return INVALID_ARGUMENT_NUMBER;
}
// create the user directory
int result = initialize_user(user);
if (result != 0) {
return result;
}
// create the log directory for the job
char *job_log_dir = get_job_log_directory(jobid);
if (job_log_dir == NULL) {
return -1;
}
result = create_directory_for_user(job_log_dir);
free(job_log_dir);
if (result != 0) {
return -1;
}
// open up the credentials file
int cred_file = open_file_as_task_tracker(credentials);
if (cred_file == -1) {
return -1;
}
int job_file = open_file_as_task_tracker(job_xml);
if (job_file == -1) {
return -1;
}
// give up root privs
if (change_user(user_detail->pw_uid, user_detail->pw_gid) != 0) {
return -1;
}
// 750
mode_t permissions = S_IRWXU | S_IRGRP | S_IXGRP;
char **tt_roots = get_values(TT_SYS_DIR_KEY);
if (tt_roots == NULL) {
return INVALID_CONFIG_FILE;
}
char **tt_root;
char *primary_job_dir = NULL;
for(tt_root=tt_roots; *tt_root != NULL; ++tt_root) {
char *job_dir = get_job_directory(*tt_root, user, jobid);
if (job_dir == NULL) {
// try the next one
} else if (mkdirs(job_dir, permissions) != 0) {
free(job_dir);
} else if (primary_job_dir == NULL) {
primary_job_dir = job_dir;
} else {
free(job_dir);
}
}
free_values(tt_roots);
if (primary_job_dir == NULL) {
fprintf(LOGFILE, "Did not create any job directories\n");
return -1;
}
char *cred_file_name = concatenate("%s/%s", "cred file", 2,
primary_job_dir, CREDENTIALS_FILENAME);
if (cred_file_name == NULL) {
return -1;
}
if (copy_file(cred_file, credentials, cred_file_name, S_IRUSR|S_IWUSR) != 0){
return -1;
}
char *job_file_name = concatenate("%s/%s", "job file", 2,
primary_job_dir, JOB_FILENAME);
if (job_file_name == NULL) {
return -1;
}
if (copy_file(job_file, job_xml, job_file_name,
S_IRUSR|S_IWUSR|S_IRGRP) != 0) {
return -1;
}
fclose(stdin);
fflush(LOGFILE);
if (LOGFILE != stdout) {
fclose(stdout);
}
fclose(stderr);
if (chdir(primary_job_dir)) {
fprintf(LOGFILE, "Failure to chdir to job dir - %s\n",
strerror(errno));
return -1;
}
execvp(args[0], args);
fprintf(LOGFILE, "Failure to exec job initialization process - %s\n",
strerror(errno));
return -1;
}
/**
* Function to prepare the application directories for the container.
*/
int initialize_app(const char *user, const char *app_id,
const char* nmPrivate_credentials_file, char* const* args) {
if (app_id == NULL || user == NULL) {
fprintf(LOGFILE, "Either app_id is null or the user passed is null.\n");
return INVALID_ARGUMENT_NUMBER;
}
// create the user directory on all disks
int result = initialize_user(user);
if (result != 0) {
return result;
}
////////////// create the log directories for the app on all disks
char **log_roots = get_values(NM_LOG_DIR_KEY);
if (log_roots == NULL) {
return INVALID_CONFIG_FILE;
}
char **log_root;
char *any_one_app_log_dir = NULL;
for(log_root=log_roots; *log_root != NULL; ++log_root) {
char *app_log_dir = get_app_log_directory(*log_root, app_id);
if (app_log_dir == NULL) {
// try the next one
} else if (create_directory_for_user(app_log_dir) != 0) {
free(app_log_dir);
return -1;
} else if (any_one_app_log_dir == NULL) {
any_one_app_log_dir = app_log_dir;
} else {
free(app_log_dir);
}
}
free_values(log_roots);
if (any_one_app_log_dir == NULL) {
fprintf(LOGFILE, "Did not create any app-log directories\n");
return -1;
}
free(any_one_app_log_dir);
////////////// End of creating the log directories for the app on all disks
// open up the credentials file
int cred_file = open_file_as_nm(nmPrivate_credentials_file);
if (cred_file == -1) {
return -1;
}
// give up root privs
if (change_user(user_detail->pw_uid, user_detail->pw_gid) != 0) {
return -1;
}
// 750
mode_t permissions = S_IRWXU | S_IRGRP | S_IXGRP;
char **nm_roots = get_values(NM_SYS_DIR_KEY);
if (nm_roots == NULL) {
return INVALID_CONFIG_FILE;
}
char **nm_root;
char *primary_app_dir = NULL;
for(nm_root=nm_roots; *nm_root != NULL; ++nm_root) {
char *app_dir = get_app_directory(*nm_root, user, app_id);
if (app_dir == NULL) {
// try the next one
} else if (mkdirs(app_dir, permissions) != 0) {
free(app_dir);
} else if (primary_app_dir == NULL) {
primary_app_dir = app_dir;
} else {
free(app_dir);
}
}
free_values(nm_roots);
if (primary_app_dir == NULL) {
fprintf(LOGFILE, "Did not create any app directories\n");
return -1;
}
char *nmPrivate_credentials_file_copy = strdup(nmPrivate_credentials_file);
// TODO: FIXME. The user's copy of creds should go to a path selected by
// localDirAllocatoir
char *cred_file_name = concatenate("%s/%s", "cred file", 2,
primary_app_dir, basename(nmPrivate_credentials_file_copy));
if (cred_file_name == NULL) {
free(nmPrivate_credentials_file_copy);
return -1;
}
if (copy_file(cred_file, nmPrivate_credentials_file,
cred_file_name, S_IRUSR|S_IWUSR) != 0){
free(nmPrivate_credentials_file_copy);
return -1;
}
free(nmPrivate_credentials_file_copy);
fclose(stdin);
fflush(LOGFILE);
if (LOGFILE != stdout) {
fclose(stdout);
}
if (ERRORFILE != stderr) {
fclose(stderr);
}
if (chdir(primary_app_dir) != 0) {
fprintf(LOGFILE, "Failed to chdir to app dir - %s\n", strerror(errno));
return -1;
}
execvp(args[0], args);
fprintf(ERRORFILE, "Failure to exec app initialization process - %s\n",
strerror(errno));
return -1;
}
