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