diff --git a/NEWS b/NEWS
index 241acd296fa15434dbcbe169e5fed6a9b86111e2..a524fd38009438a53719ea797a6f7ed20f818ebc 100644
--- a/NEWS
+++ b/NEWS
@@ -48,6 +48,7 @@ documents those changes that are of interest to users and administrators.
     of a node's memory and FastSchedule=0 is configurated. Intel KNL memory size
     can change on reboot with various MCDRAM modes.
  -- Fix small memory leak when printing HealthCheckNodeState.
+ -- Eliminate memory leaks when AuthInfo is configured.
 
 * Changes in Slurm 16.05.0
 ==========================
diff --git a/src/api/allocate.c b/src/api/allocate.c
index 92704ed8f5ab6f4a0cb523006257e7e7d1d954be..4e49b9589707cce4026c6f101e3272d48980cf3f 100644
--- a/src/api/allocate.c
+++ b/src/api/allocate.c
@@ -744,12 +744,15 @@ static void _destroy_allocation_response_socket(listen_t *listen)
 static int
 _handle_msg(slurm_msg_t *msg, resource_allocation_response_msg_t **resp)
 {
-	uid_t req_uid   = g_slurm_auth_get_uid(msg->auth_cred,
-					       slurm_get_auth_info());
+	char *auth_info = slurm_get_auth_info();
+	uid_t req_uid;
 	uid_t uid       = getuid();
 	uid_t slurm_uid = (uid_t) slurm_get_slurm_user_id();
 	int rc = 0;
 
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, auth_info);
+	xfree(auth_info);
+
 	if ((req_uid != slurm_uid) && (req_uid != 0) && (req_uid != uid)) {
 		error ("Security violation, slurm message from uid %u",
 			(unsigned int) req_uid);
diff --git a/src/api/allocate_msg.c b/src/api/allocate_msg.c
index 26b5c67a4e1db383c4bd2941542221c9ba83a107..13c5b6161d4280144e432bd72282ffbb238d6ba5 100644
--- a/src/api/allocate_msg.c
+++ b/src/api/allocate_msg.c
@@ -245,12 +245,15 @@ static void _handle_suspend(struct allocation_msg_thread *msg_thr,
 static void
 _handle_msg(void *arg, slurm_msg_t *msg)
 {
+	char *auth_info = slurm_get_auth_info();
 	struct allocation_msg_thread *msg_thr =
 		(struct allocation_msg_thread *)arg;
-	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+	uid_t req_uid;
 	uid_t uid = getuid();
 
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, auth_info);
+	xfree(auth_info);
+
 	if ((req_uid != slurm_uid) && (req_uid != 0) && (req_uid != uid)) {
 		error ("Security violation, slurm message from uid %u",
 		       (unsigned int) req_uid);
diff --git a/src/api/step_launch.c b/src/api/step_launch.c
index ed02de0c2289f03ba929f4debe9a1c9d7f1a9bbc..4de72b6bdb28e4fafc3a1f7bdfe5cfb93055962b 100644
--- a/src/api/step_launch.c
+++ b/src/api/step_launch.c
@@ -1495,13 +1495,16 @@ _task_user_managed_io_handler(struct step_launch_state *sls,
 static void
 _handle_msg(void *arg, slurm_msg_t *msg)
 {
+	char *auth_info = slurm_get_auth_info();
 	struct step_launch_state *sls = (struct step_launch_state *)arg;
-	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+	uid_t req_uid;
 	uid_t uid = getuid();
 	srun_user_msg_t *um;
 	int rc;
 
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, auth_info);
+	xfree(auth_info);
+
 	if ((req_uid != slurm_uid) && (req_uid != 0) && (req_uid != uid)) {
 		error ("Security violation, slurm message from uid %u",
 		       (unsigned int) req_uid);
diff --git a/src/common/slurm_protocol_api.c b/src/common/slurm_protocol_api.c
index 6236d13fd5c2ddae2b5c213c38eaacb6c42e4e05..758584c9b72d28a6b32cf4fa513f7db94c85899d 100644
--- a/src/common/slurm_protocol_api.c
+++ b/src/common/slurm_protocol_api.c
@@ -1745,7 +1745,7 @@ char *slurm_get_accounting_storage_pass(void)
  * returns the auth_info from slurmctld_conf object (AuthInfo parameter)
  * cache value in local buffer for best performance
  * WARNING: The return of this function can be used in many different
- * places and SHOULD NOT BE FREED!
+ * RET char * - AuthInfo value,  MUST be xfreed by caller
  */
 extern char *slurm_get_auth_info(void)
 {
@@ -3391,11 +3391,13 @@ total_return:
 static int _unpack_msg_uid(Buf buffer)
 {
 	int uid = -1;
-	void *auth_cred = NULL;
+	void *auth_cred = NULL, *auth_info;
 
 	if ((auth_cred = g_slurm_auth_unpack(buffer)) == NULL)
 		return uid;
-	uid = (int) g_slurm_auth_get_uid(auth_cred, slurm_get_auth_info());
+	auth_info = slurm_get_auth_info();
+	uid = (int) g_slurm_auth_get_uid(auth_cred, auth_info);
+	xfree(auth_info);
 	g_slurm_auth_destroy(auth_cred);
 
 	return uid;
diff --git a/src/common/slurm_protocol_pack.c b/src/common/slurm_protocol_pack.c
index cd42996e44f4a24734ce7c39b49c4e52f9bd0667..fc5432578934973dbb02a2e8967f26b6fa6da4f9 100644
--- a/src/common/slurm_protocol_pack.c
+++ b/src/common/slurm_protocol_pack.c
@@ -4725,13 +4725,12 @@ _pack_composite_msg(composite_msg_t *msg, Buf buffer, uint16_t protocol_version)
 			pack16(tmp_info->msg_index, buffer);
 
 			if (!tmp_info->auth_cred) {
-				char *auth = slurm_get_auth_info();
+				char *auth_info = slurm_get_auth_info();
 				/* FIXME: this should handle the
-				   _global_auth_key() as well.
-				*/
+				 * _global_auth_key() as well. */
 				tmp_info->auth_cred =
-					g_slurm_auth_create(NULL, 2, auth);
-				xfree(auth);
+					g_slurm_auth_create(NULL, 2, auth_info);
+				xfree(auth_info);
 			}
 
 			g_slurm_auth_pack(tmp_info->auth_cred, buffer);
@@ -4771,7 +4770,7 @@ _unpack_composite_msg(composite_msg_t **msg, Buf buffer,
 	int i, rc;
 	slurm_msg_t *tmp_info;
 	composite_msg_t *object_ptr = NULL;
-	char *auth = slurm_get_auth_info();
+	char *auth_info = slurm_get_auth_info();
 
 	xassert(msg);
 	object_ptr = xmalloc(sizeof(composite_msg_t));
@@ -4803,7 +4802,7 @@ _unpack_composite_msg(composite_msg_t **msg, Buf buffer,
 				goto unpack_error;
 
 			rc = g_slurm_auth_verify(
-				tmp_info->auth_cred, NULL, 2, auth);
+				tmp_info->auth_cred, NULL, 2, auth_info);
 
 			if (rc != SLURM_SUCCESS) {
 				error("authentication: %s ",
@@ -4815,12 +4814,12 @@ _unpack_composite_msg(composite_msg_t **msg, Buf buffer,
 				list_append(object_ptr->msg_list, tmp_info);
 		}
 	}
-	xfree(auth);
+	xfree(auth_info);
 	return SLURM_SUCCESS;
 unpack_error:
 	slurm_free_composite_msg(object_ptr);
 	*msg = NULL;
-	xfree(auth);
+	xfree(auth_info);
 	return SLURM_ERROR;
 }
 
diff --git a/src/common/stepd_api.c b/src/common/stepd_api.c
index ff609dd66e2a2e61667b8dc6a782394b41d7547a..e27dc064f034a00c396ff199ff7bdeee414b2c02 100644
--- a/src/common/stepd_api.c
+++ b/src/common/stepd_api.c
@@ -223,6 +223,7 @@ stepd_connect(const char *directory, const char *nodename,
 	int fd = -1;
 	int rc;
 	void *auth_cred;
+	char *auth_info;
 	Buf buffer;
 	int len;
 
@@ -243,7 +244,9 @@ stepd_connect(const char *directory, const char *nodename,
 
 	buffer = init_buf(0);
 	/* Create an auth credential */
-	auth_cred = g_slurm_auth_create(NULL, 2, slurm_get_auth_info());
+	auth_info = slurm_get_auth_info();
+	auth_cred = g_slurm_auth_create(NULL, 2, auth_info);
+	xfree(auth_info);
 	if (auth_cred == NULL) {
 		error("Creating authentication credential: %s",
 		      g_slurm_auth_errstr(g_slurm_auth_errno(NULL)));
diff --git a/src/plugins/crypto/munge/crypto_munge.c b/src/plugins/crypto/munge/crypto_munge.c
index 14a1000a511fa5416b8a92051a2c7d01cd5b0d83..6657aa7c23fda9a4d17bbaf2a900e96b06430402 100644
--- a/src/plugins/crypto/munge/crypto_munge.c
+++ b/src/plugins/crypto/munge/crypto_munge.c
@@ -103,17 +103,17 @@ static uid_t slurm_user = 0;
 static char *_auth_opts_to_socket(void)
 {
 	char *socket = NULL, *sep, *tmp;
-	char *opts = slurm_get_auth_info();
+	char *auth_info = slurm_get_auth_info();
 
-	if (opts) {
-		tmp = strstr(opts, "socket=");
+	if (auth_info) {
+		tmp = strstr(auth_info, "socket=");
 		if (tmp) {	/* New format */
 			socket = xstrdup(tmp + 7);
 			sep = strchr(socket, ',');
 			if (sep)
 				sep[0] = '\0';
 		}
-		xfree(opts);
+		xfree(auth_info);
 	}
 
 	return socket;
diff --git a/src/plugins/launch/aprun/launch_aprun.c b/src/plugins/launch/aprun/launch_aprun.c
index 57991b82ed57f711847efae902fa3bff948c86d9..9bba788745ecd43d5f495eaf2283ad383b838c98 100644
--- a/src/plugins/launch/aprun/launch_aprun.c
+++ b/src/plugins/launch/aprun/launch_aprun.c
@@ -312,12 +312,15 @@ static void _handle_timeout(srun_timeout_msg_t *timeout_msg)
 static void _handle_msg(slurm_msg_t *msg)
 {
 	static uint32_t slurm_uid = NO_VAL;
-	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+	char *auth_info = slurm_get_auth_info();
+	uid_t req_uid;
 	uid_t uid = getuid();
 	job_step_kill_msg_t *ss;
 	srun_user_msg_t *um;
 
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, auth_info);
+	xfree(auth_info);
+
 	if (slurm_uid == NO_VAL)
 		slurm_uid = slurm_get_slurm_user_id();
 	if ((req_uid != slurm_uid) && (req_uid != 0) && (req_uid != uid)) {
diff --git a/src/plugins/launch/runjob/launch_runjob.c b/src/plugins/launch/runjob/launch_runjob.c
index 449664877dbe3857ea59482a1227049ba296f1a9..f151019549bdfecaf6076bed2a4be5da7408b2a9 100644
--- a/src/plugins/launch/runjob/launch_runjob.c
+++ b/src/plugins/launch/runjob/launch_runjob.c
@@ -131,12 +131,15 @@ static void
 _handle_msg(slurm_msg_t *msg)
 {
 	static uint32_t slurm_uid = NO_VAL;
-	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+	char *auth_info = slurm_get_auth_info();
+	uid_t req_uid;
 	uid_t uid = getuid();
 	job_step_kill_msg_t *ss;
 	srun_user_msg_t *um;
 
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, auth_info);
+	xfree(auth_info);
+
 	if (slurm_uid == NO_VAL)
 		slurm_uid = slurm_get_slurm_user_id();
 	if ((req_uid != slurm_uid) && (req_uid != 0) && (req_uid != uid)) {
diff --git a/src/plugins/mpi/pmi2/spawn.c b/src/plugins/mpi/pmi2/spawn.c
index 336e4d0ecb037e593205461f6be0da358cd8b8c9..759e05f4e60517a0ea504275f12a090feab7f3eb 100644
--- a/src/plugins/mpi/pmi2/spawn.c
+++ b/src/plugins/mpi/pmi2/spawn.c
@@ -149,8 +149,10 @@ spawn_req_pack(spawn_req_t *req, Buf buf)
 	int i, j;
 	spawn_subcmd_t *subcmd;
 	void *auth_cred;
+	char *auth_info = slurm_get_auth_info();
 
-	auth_cred = g_slurm_auth_create(NULL, 2, slurm_get_auth_info());
+	auth_cred = g_slurm_auth_create(NULL, 2, auth_info);
+	xfree(auth_info);
 	if (auth_cred == NULL) {
 		error("authentication: %s",
 		      g_slurm_auth_errstr(g_slurm_auth_errno(NULL)) );
@@ -192,6 +194,7 @@ spawn_req_unpack(spawn_req_t **req_ptr, Buf buf)
 	uint32_t temp32;
 	int i, j;
 	void *auth_cred;
+	char *auth_info;
 	uid_t auth_uid, my_uid;
 
 	auth_cred = g_slurm_auth_unpack(buf);
@@ -200,7 +203,9 @@ spawn_req_unpack(spawn_req_t **req_ptr, Buf buf)
 		      g_slurm_auth_errstr(g_slurm_auth_errno(NULL)) );
 		return SLURM_ERROR;
 	}
-	auth_uid = g_slurm_auth_get_uid(auth_cred, slurm_get_auth_info());
+	auth_info = slurm_get_auth_info();
+	auth_uid = g_slurm_auth_get_uid(auth_cred, auth_info);
+	xfree(auth_info);
 	(void) g_slurm_auth_destroy(auth_cred);
 	my_uid = getuid();
 	if ((auth_uid != 0) && (auth_uid != my_uid)) {
diff --git a/src/sattach/sattach.c b/src/sattach/sattach.c
index b404107686bbf21d799b8b751574fb9aabc29387..5d6d195769ad34de863e8638eb87927fb4f5af97 100644
--- a/src/sattach/sattach.c
+++ b/src/sattach/sattach.c
@@ -575,13 +575,16 @@ _exit_handler(message_thread_state_t *mts, slurm_msg_t *exit_msg)
 static void
 _handle_msg(void *arg, slurm_msg_t *msg)
 {
-	message_thread_state_t *mts = (message_thread_state_t *)arg;
-	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
 	static uid_t slurm_uid;
 	static bool slurm_uid_set = false;
+	message_thread_state_t *mts = (message_thread_state_t *)arg;
+	char *auth_info = slurm_get_auth_info();
+	uid_t req_uid;
 	uid_t uid = getuid();
 
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, auth_info);
+	xfree(auth_info);
+
 	if (!slurm_uid_set) {
 		slurm_uid = slurm_get_slurm_user_id();
 		slurm_uid_set = true;
diff --git a/src/slurmctld/backup.c b/src/slurmctld/backup.c
index dbe1b32b89d4996ff09f541d45a11b4987c7641b..2060b1edad47ac0debf88ffa611df4c0812731a8 100644
--- a/src/slurmctld/backup.c
+++ b/src/slurmctld/backup.c
@@ -385,8 +385,10 @@ static int _background_process_msg(slurm_msg_t * msg)
 
 	if (msg->msg_type != REQUEST_PING) {
 		bool super_user = false;
-		uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
-						 slurm_get_auth_info());
+		char *auth_info = slurm_get_auth_info();
+		uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, auth_info);
+
+		xfree(auth_info);
 		if ((uid == 0) || (uid == getuid()))
 			super_user = true;
 
diff --git a/src/slurmctld/controller.c b/src/slurmctld/controller.c
index e63a05a5c730d62d43b8e14c76f9f7304546a108..e982417ce4eeee72ee2835a192df4957079f5fc3 100644
--- a/src/slurmctld/controller.c
+++ b/src/slurmctld/controller.c
@@ -460,6 +460,8 @@ int main(int argc, char *argv[])
 
 	while (1) {
 		/* initialization for each primary<->backup switch */
+		xfree(slurmctld_config.auth_info);
+		slurmctld_config.auth_info = slurm_get_auth_info();
 		slurmctld_config.shutdown_time = (time_t) 0;
 		slurmctld_config.resume_backup = false;
 
@@ -735,6 +737,7 @@ int main(int argc, char *argv[])
 
 #endif
 
+	xfree(slurmctld_config.auth_info);
 	xfree(slurmctld_cluster_name);
 	if (cnt) {
 		info("Slurmctld shutdown completing with %d active agent "
diff --git a/src/slurmctld/proc_req.c b/src/slurmctld/proc_req.c
index c8268f0b11f939bcf1dcbff9b4d67cf90e16a7bb..ac43c37bf79f4bfa912f0e82a916be12872ebcd8 100644
--- a/src/slurmctld/proc_req.c
+++ b/src/slurmctld/proc_req.c
@@ -219,7 +219,7 @@ void slurmctld_req(slurm_msg_t *msg, connection_arg_t *arg)
 
 	/* Just to validate the cred */
 	rpc_uid = (uint32_t) g_slurm_auth_get_uid(msg->auth_cred,
-						  slurm_get_auth_info());
+						  slurmctld_config.auth_info);
 	if (g_slurm_auth_errno(msg->auth_cred) != SLURM_SUCCESS) {
 		error("Bad authentication: %s",
 		      g_slurm_auth_errstr(g_slurm_auth_errno(msg->auth_cred)));
@@ -962,7 +962,8 @@ static void _slurm_rpc_allocate_resources(slurm_msg_t * msg)
 	/* Locks: Read config, write job, write node, read partition */
 	slurmctld_lock_t job_write_lock = {
 		READ_LOCK, WRITE_LOCK, WRITE_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	int immediate = job_desc_msg->immediate;
 	bool do_unlock = false;
 	bool job_waiting = false;
@@ -1174,7 +1175,8 @@ static void _slurm_rpc_dump_conf(slurm_msg_t * msg)
 	/* Locks: Read config, partition*/
 	slurmctld_lock_t config_read_lock = {
 		READ_LOCK, NO_LOCK, NO_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_BUILD_INFO from uid=%d",
@@ -1217,7 +1219,8 @@ static void _slurm_rpc_dump_jobs(slurm_msg_t * msg)
 	/* Locks: Read config job, write partition (for hiding) */
 	slurmctld_lock_t job_read_lock = {
 		READ_LOCK, READ_LOCK, NO_LOCK, WRITE_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug3("Processing RPC: REQUEST_JOB_INFO from uid=%d", uid);
@@ -1231,7 +1234,7 @@ static void _slurm_rpc_dump_jobs(slurm_msg_t * msg)
 		pack_all_jobs(&dump, &dump_size,
 			      job_info_request_msg->show_flags,
 			      g_slurm_auth_get_uid(msg->auth_cred,
-						   slurm_get_auth_info()),
+						   slurmctld_config.auth_info),
 			      NO_VAL, msg->protocol_version);
 		unlock_slurmctld(job_read_lock);
 		END_TIMER2("_slurm_rpc_dump_jobs");
@@ -1266,7 +1269,8 @@ static void _slurm_rpc_dump_jobs_user(slurm_msg_t * msg)
 	/* Locks: Read config job, write node (for hiding) */
 	slurmctld_lock_t job_read_lock = {
 		READ_LOCK, READ_LOCK, NO_LOCK, WRITE_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug3("Processing RPC: REQUEST_JOB_USER_INFO from uid=%d", uid);
@@ -1274,7 +1278,7 @@ static void _slurm_rpc_dump_jobs_user(slurm_msg_t * msg)
 	pack_all_jobs(&dump, &dump_size,
 		      job_info_request_msg->show_flags,
 		      g_slurm_auth_get_uid(msg->auth_cred,
-					   slurm_get_auth_info()),
+					   slurmctld_config.auth_info),
 		      job_info_request_msg->user_id, msg->protocol_version);
 	unlock_slurmctld(job_read_lock);
 	END_TIMER2("_slurm_rpc_dump_job_user");
@@ -1307,7 +1311,8 @@ static void _slurm_rpc_dump_job_single(slurm_msg_t * msg)
 	/* Locks: Read config, job, and node info */
 	slurmctld_lock_t job_read_lock = {
 		READ_LOCK, READ_LOCK, NO_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug3("Processing RPC: REQUEST_JOB_INFO_SINGLE from uid=%d", uid);
@@ -1316,7 +1321,7 @@ static void _slurm_rpc_dump_job_single(slurm_msg_t * msg)
 	rc = pack_one_job(&dump, &dump_size, job_id_msg->job_id,
 			  job_id_msg->show_flags,
 			  g_slurm_auth_get_uid(msg->auth_cred,
-					       slurm_get_auth_info()),
+					       slurmctld_config.auth_info),
 			  msg->protocol_version);
 	unlock_slurmctld(job_read_lock);
 	END_TIMER2("_slurm_rpc_dump_job_single");
@@ -1347,7 +1352,8 @@ static void  _slurm_rpc_get_shares(slurm_msg_t *msg)
 	shares_response_msg_t resp_msg;
 	slurm_msg_t response_msg;
 
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_SHARE_INFO from uid=%d", uid);
@@ -1376,7 +1382,8 @@ static void  _slurm_rpc_get_priority_factors(slurm_msg_t *msg)
 	priority_factors_response_msg_t resp_msg;
 	slurm_msg_t response_msg;
 
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_PRIORITY_FACTORS from uid=%d", uid);
@@ -1406,7 +1413,8 @@ static void _slurm_rpc_end_time(slurm_msg_t * msg)
 	/* Locks: Read job */
 	slurmctld_lock_t job_read_lock = {
 		NO_LOCK, READ_LOCK, NO_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_JOB_END_TIME from uid=%d", uid);
@@ -1442,7 +1450,8 @@ static void _slurm_rpc_dump_front_end(slurm_msg_t * msg)
 	/* Locks: Read config, read node */
 	slurmctld_lock_t node_read_lock = {
 		READ_LOCK, NO_LOCK, NO_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug3("Processing RPC: REQUEST_FRONT_END_INFO from uid=%d", uid);
@@ -1488,7 +1497,8 @@ static void _slurm_rpc_dump_nodes(slurm_msg_t * msg)
 	 * select plugins) */
 	slurmctld_lock_t node_write_lock = {
 		READ_LOCK, NO_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug3("Processing RPC: REQUEST_NODE_INFO from uid=%d", uid);
@@ -1545,7 +1555,8 @@ static void _slurm_rpc_dump_node_single(slurm_msg_t * msg)
 	/* Locks: Read config, read node */
 	slurmctld_lock_t node_read_lock = {
 		READ_LOCK, NO_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug3("Processing RPC: REQUEST_NODE_INFO_SINGLE from uid=%d", uid);
@@ -1600,7 +1611,8 @@ static void _slurm_rpc_dump_partitions(slurm_msg_t * msg)
 	/* Locks: Read configuration and partition */
 	slurmctld_lock_t part_read_lock = {
 		READ_LOCK, NO_LOCK, NO_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_PARTITION_INFO uid=%d", uid);
@@ -1653,7 +1665,8 @@ static void  _slurm_rpc_epilog_complete(slurm_msg_t *msg,
 	/* Locks: Read configuration, write job, write node */
 	slurmctld_lock_t job_write_lock = {
 		READ_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	epilog_complete_msg_t *epilog_msg =
 		(epilog_complete_msg_t *) msg->data;
 	struct job_record  *job_ptr;
@@ -1741,7 +1754,8 @@ static void _slurm_rpc_job_step_kill(slurm_msg_t * msg)
 	/* Locks: Read config, write job, write node */
 	slurmctld_lock_t job_write_lock = {
 		READ_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	struct job_record *job_ptr;
 
 	START_TIMER;
@@ -1856,7 +1870,8 @@ static void _slurm_rpc_complete_job_allocation(slurm_msg_t * msg)
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK
 	};
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	struct job_record *job_ptr;
 	char jbuf[JBUFSIZ];
 
@@ -1956,7 +1971,8 @@ static void _slurm_rpc_complete_batch_script(slurm_msg_t * msg, bool locked)
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK
 	};
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	bool job_requeue = false;
 	bool dump_job = false, dump_node = false, run_sched = false;
 	struct job_record *job_ptr = NULL;
@@ -2196,7 +2212,8 @@ static void _slurm_rpc_job_step_create(slurm_msg_t * msg)
 	/* Locks: Write jobs, read nodes */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	if (slurmctld_conf.debug_flags & DEBUG_FLAG_STEPS)
@@ -2304,7 +2321,8 @@ static void _slurm_rpc_job_step_get_info(slurm_msg_t * msg)
 	/* Locks: Read config, job, write partition (for filtering) */
 	slurmctld_lock_t job_read_lock = {
 		READ_LOCK, READ_LOCK, NO_LOCK, WRITE_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	if (slurmctld_conf.debug_flags & DEBUG_FLAG_STEPS)
@@ -2394,7 +2412,8 @@ static void _slurm_rpc_job_will_run(slurm_msg_t * msg)
 	/* Locks: Write job, read node, read partition */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, READ_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	uint16_t port;	/* dummy value */
 	slurm_addr_t resp_addr;
 	will_run_response_msg_t *resp = NULL;
@@ -2488,7 +2507,8 @@ static void _slurm_rpc_node_registration(slurm_msg_t * msg,
 	/* Locks: Read config, write job, write node */
 	slurmctld_lock_t job_write_lock = {
 		READ_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: MESSAGE_NODE_REGISTRATION_STATUS from uid=%d",
@@ -2562,7 +2582,8 @@ static void _slurm_rpc_job_alloc_info(slurm_msg_t * msg)
 	/* Locks: Read config, job, read node */
 	slurmctld_lock_t job_read_lock = {
 		READ_LOCK, READ_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_JOB_ALLOCATION_INFO from uid=%d", uid);
@@ -2639,7 +2660,8 @@ static void _slurm_rpc_job_alloc_info_lite(slurm_msg_t * msg)
 	/* Locks: Read config, job, read node */
 	slurmctld_lock_t job_read_lock = {
 		READ_LOCK, READ_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_JOB_ALLOCATION_INFO_LITE from uid=%d",
@@ -2779,7 +2801,8 @@ static void _slurm_rpc_job_sbcast_cred(slurm_msg_t * msg)
 	/* Locks: Read config, job, read node */
 	slurmctld_lock_t job_read_lock = {
 		READ_LOCK, READ_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_JOB_SBCAST_CRED from uid=%d", uid);
@@ -2901,7 +2924,8 @@ static void _slurm_rpc_reconfigure_controller(slurm_msg_t * msg)
 	/* Locks: Write configuration, job, node and partition */
 	slurmctld_lock_t config_write_lock = {
 		WRITE_LOCK, WRITE_LOCK, WRITE_LOCK, WRITE_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	info("Processing RPC: REQUEST_RECONFIGURE from uid=%d", uid);
@@ -2952,7 +2976,8 @@ static void _slurm_rpc_reconfigure_controller(slurm_msg_t * msg)
 static void _slurm_rpc_takeover(slurm_msg_t * msg)
 {
 	int error_code = SLURM_SUCCESS;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	/* We could authenticate here, if desired */
 	if (!validate_super_user(uid)) {
@@ -2975,7 +3000,8 @@ static void _slurm_rpc_shutdown_controller(slurm_msg_t * msg)
 	int error_code = SLURM_SUCCESS, i;
 	uint16_t options = 0;
 	shutdown_msg_t *shutdown_msg = (shutdown_msg_t *) msg->data;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	/* Locks: Read node */
 	slurmctld_lock_t node_read_lock = {
 		NO_LOCK, NO_LOCK, READ_LOCK, NO_LOCK };
@@ -3045,7 +3071,8 @@ static void _slurm_rpc_shutdown_controller(slurm_msg_t * msg)
 static void _slurm_rpc_shutdown_controller_immediate(slurm_msg_t * msg)
 {
 	int error_code = SLURM_SUCCESS;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	if (!validate_super_user(uid)) {
 		error("Security violation, SHUTDOWN_IMMEDIATE RPC from uid=%d",
@@ -3073,7 +3100,8 @@ static void _slurm_rpc_step_complete(slurm_msg_t *msg, bool locked)
 	/* Locks: Write job, write node */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	bool dump_job = false, dump_node = false;
 
 	/* init */
@@ -3169,7 +3197,8 @@ static void _slurm_rpc_step_layout(slurm_msg_t *msg)
 	/* Locks: Read config job, write node */
 	slurmctld_lock_t job_read_lock = {
 		READ_LOCK, READ_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	struct job_record *job_ptr = NULL;
 	struct step_record *step_ptr = NULL;
 
@@ -3231,7 +3260,8 @@ static void _slurm_rpc_step_update(slurm_msg_t *msg)
 	/* Locks: Write job */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, NO_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	int rc;
 
 	START_TIMER;
@@ -3263,7 +3293,8 @@ static void _slurm_rpc_submit_batch_job(slurm_msg_t * msg)
 	/* Locks: Write job, read node, read partition */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, READ_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	char *err_msg = NULL;
 
 	START_TIMER;
@@ -3438,7 +3469,8 @@ static void _slurm_rpc_update_job(slurm_msg_t * msg)
 	/* Locks: Write job, read node, read partition */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, READ_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_UPDATE_JOB from uid=%d", uid);
@@ -3536,7 +3568,8 @@ static void _slurm_rpc_update_front_end(slurm_msg_t * msg)
 	/* Locks: write node */
 	slurmctld_lock_t node_write_lock = {
 		NO_LOCK, NO_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_UPDATE_FRONT_END from uid=%d", uid);
@@ -3580,7 +3613,8 @@ static void _slurm_rpc_update_node(slurm_msg_t * msg)
 	/* Locks: Write job and write node */
 	slurmctld_lock_t node_write_lock = {
 		NO_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_UPDATE_NODE from uid=%d", uid);
@@ -3628,7 +3662,8 @@ static void _slurm_rpc_update_layout(slurm_msg_t * msg)
 	int shrink_size;
 
 	/* Locks: Write job and write node */
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_UPDATE_LAYOUT from uid=%d", uid);
@@ -3672,7 +3707,8 @@ static void _slurm_rpc_update_partition(slurm_msg_t * msg)
 	 * NOTE: job write lock due to gang scheduler support */
 	slurmctld_lock_t part_write_lock = {
 		READ_LOCK, WRITE_LOCK, READ_LOCK, WRITE_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_UPDATE_PARTITION from uid=%d", uid);
@@ -3723,7 +3759,8 @@ static void _slurm_rpc_update_powercap(slurm_msg_t * msg)
 	/* Locks: write configuration, read node */
 	slurmctld_lock_t config_write_lock = {
 		WRITE_LOCK, NO_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_UPDATE_POWERCAP from uid=%d", uid);
@@ -3789,7 +3826,8 @@ static void _slurm_rpc_delete_partition(slurm_msg_t * msg)
 	/* Locks: write job, read node, write partition */
 	slurmctld_lock_t part_write_lock = {
 		NO_LOCK, WRITE_LOCK, READ_LOCK, WRITE_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_DELETE_PARTITION from uid=%d", uid);
@@ -3832,7 +3870,8 @@ static void _slurm_rpc_resv_create(slurm_msg_t * msg)
 	/* Locks: write node, read partition */
 	slurmctld_lock_t node_write_lock = {
 		NO_LOCK, NO_LOCK, WRITE_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_CREATE_RESERVATION from uid=%d", uid);
@@ -3889,7 +3928,8 @@ static void _slurm_rpc_resv_update(slurm_msg_t * msg)
 	/* Locks: write node, read partition */
 	slurmctld_lock_t node_write_lock = {
 		NO_LOCK, NO_LOCK, WRITE_LOCK, READ_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_UPDATE_RESERVATION from uid=%d", uid);
@@ -3932,7 +3972,8 @@ static void _slurm_rpc_resv_delete(slurm_msg_t * msg)
 	/* Locks: read job, write node */
 	slurmctld_lock_t node_write_lock = {
 		NO_LOCK, READ_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_DELETE_RESERVATION from uid=%d", uid);
@@ -3977,7 +4018,8 @@ static void _slurm_rpc_resv_show(slurm_msg_t * msg)
 	/* Locks: read node */
 	slurmctld_lock_t node_read_lock = {
 		NO_LOCK, NO_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	slurm_msg_t response_msg;
 	char *dump;
 	int dump_size;
@@ -4069,7 +4111,8 @@ static void _slurm_rpc_update_block(slurm_msg_t * msg)
 	int error_code = SLURM_SUCCESS;
 	DEF_TIMERS;
 	update_block_msg_t *block_desc_ptr = (update_block_msg_t *) msg->data;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	char *name = NULL;
 	START_TIMER;
 
@@ -4182,7 +4225,8 @@ static void  _slurm_rpc_block_info(slurm_msg_t * msg)
 	slurmctld_lock_t config_read_lock = {
 		READ_LOCK, NO_LOCK, NO_LOCK, NO_LOCK };
 	DEF_TIMERS;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_BLOCK_INFO from uid=%d", uid);
@@ -4225,7 +4269,8 @@ static void  _slurm_rpc_block_info(slurm_msg_t * msg)
 /* get node select info plugin */
 static void  _slurm_rpc_burst_buffer_info(slurm_msg_t * msg)
 {
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	void *resp_buffer = NULL;
 	int resp_buffer_size = 0;
 	int error_code = SLURM_SUCCESS;
@@ -4278,7 +4323,8 @@ inline static void _slurm_rpc_suspend(slurm_msg_t * msg)
 	/* Locks: write job and node */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	char *op;
 
 	START_TIMER;
@@ -4330,7 +4376,8 @@ inline static void _slurm_rpc_top_job(slurm_msg_t * msg)
 	/* Locks: write job */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, NO_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	debug("Processing RPC: REQUEST_TOP_JOB from uid=%u", (unsigned int)uid);
 
@@ -4358,7 +4405,8 @@ inline static void _slurm_rpc_requeue(slurm_msg_t * msg)
 	/* Locks: write job and node */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, WRITE_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 
@@ -4399,7 +4447,8 @@ inline static void  _slurm_rpc_checkpoint(slurm_msg_t * msg)
 	/* Locks: write job lock, read node lock */
 	slurmctld_lock_t job_write_lock = {
 		NO_LOCK, WRITE_LOCK, READ_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	char *op;
 
 	START_TIMER;
@@ -4483,7 +4532,8 @@ inline static void  _slurm_rpc_checkpoint_comp(slurm_msg_t * msg)
 	/* Locks: read job */
 	slurmctld_lock_t job_read_lock = {
 		NO_LOCK, READ_LOCK, NO_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("Processing RPC: REQUEST_CHECKPOINT_COMP from uid=%d", uid);
@@ -4513,7 +4563,8 @@ inline static void  _slurm_rpc_checkpoint_task_comp(slurm_msg_t * msg)
 	/* Locks: read job */
 	slurmctld_lock_t job_read_lock = {
 		NO_LOCK, READ_LOCK, NO_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	ckpt_ptr = (checkpoint_task_comp_msg_t *) msg->data;
 	START_TIMER;
@@ -4779,7 +4830,8 @@ static int _launch_batch_step(job_desc_msg_t *job_desc_msg, uid_t uid,
 inline static void  _slurm_rpc_trigger_clear(slurm_msg_t * msg)
 {
 	int rc;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	trigger_info_msg_t * trigger_ptr = (trigger_info_msg_t *) msg->data;
 	DEF_TIMERS;
 
@@ -4794,7 +4846,8 @@ inline static void  _slurm_rpc_trigger_clear(slurm_msg_t * msg)
 
 inline static void  _slurm_rpc_trigger_get(slurm_msg_t * msg)
 {
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	trigger_info_msg_t *resp_data;
 	trigger_info_msg_t * trigger_ptr = (trigger_info_msg_t *) msg->data;
 	slurm_msg_t response_msg;
@@ -4819,8 +4872,10 @@ inline static void  _slurm_rpc_trigger_get(slurm_msg_t * msg)
 inline static void  _slurm_rpc_trigger_set(slurm_msg_t * msg)
 {
 	int rc;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
-	gid_t gid = g_slurm_auth_get_gid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
+	gid_t gid = g_slurm_auth_get_gid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	trigger_info_msg_t * trigger_ptr = (trigger_info_msg_t *) msg->data;
 	DEF_TIMERS;
 
@@ -4836,7 +4891,8 @@ inline static void  _slurm_rpc_trigger_set(slurm_msg_t * msg)
 inline static void  _slurm_rpc_trigger_pull(slurm_msg_t * msg)
 {
 	int rc;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	trigger_info_msg_t * trigger_ptr = (trigger_info_msg_t *) msg->data;
 	DEF_TIMERS;
 
@@ -4936,7 +4992,8 @@ inline static void  _slurm_rpc_job_notify(slurm_msg_t * msg)
 	/* Locks: read job */
 	slurmctld_lock_t job_read_lock = {
 		NO_LOCK, READ_LOCK, NO_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	job_notify_msg_t * notify_msg = (job_notify_msg_t *) msg->data;
 	struct job_record *job_ptr;
 	DEF_TIMERS;
@@ -4965,7 +5022,8 @@ inline static void  _slurm_rpc_job_notify(slurm_msg_t * msg)
 
 inline static void  _slurm_rpc_set_debug_flags(slurm_msg_t *msg)
 {
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	slurmctld_lock_t config_write_lock =
 		{ WRITE_LOCK, NO_LOCK, NO_LOCK, NO_LOCK };
 	set_debug_flags_msg_t *request_msg =
@@ -5008,7 +5066,8 @@ inline static void  _slurm_rpc_set_debug_flags(slurm_msg_t *msg)
 inline static void  _slurm_rpc_set_debug_level(slurm_msg_t *msg)
 {
 	int debug_level, old_debug_level;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	slurmctld_lock_t config_write_lock =
 		{ WRITE_LOCK, NO_LOCK, NO_LOCK, NO_LOCK };
 	set_debug_level_msg_t *request_msg =
@@ -5064,7 +5123,8 @@ inline static void  _slurm_rpc_set_debug_level(slurm_msg_t *msg)
 inline static void  _slurm_rpc_set_schedlog_level(slurm_msg_t *msg)
 {
 	int schedlog_level, old_schedlog_level;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	slurmctld_lock_t config_read_lock =
 		{ READ_LOCK, NO_LOCK, NO_LOCK, NO_LOCK };
 	set_debug_level_msg_t *request_msg =
@@ -5115,7 +5175,8 @@ inline static void  _slurm_rpc_set_schedlog_level(slurm_msg_t *msg)
 inline static void  _slurm_rpc_accounting_update_msg(slurm_msg_t *msg)
 {
 	int rc = SLURM_SUCCESS;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	accounting_update_msg_t *update_ptr =
 		(accounting_update_msg_t *) msg->data;
 	bool sent_rc = false;
@@ -5173,7 +5234,8 @@ inline static void  _slurm_rpc_accounting_update_msg(slurm_msg_t *msg)
 inline static void _slurm_rpc_reboot_nodes(slurm_msg_t * msg)
 {
 	int rc;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 #ifndef HAVE_FRONT_END
 	int i;
 	struct node_record *node_ptr;
@@ -5237,7 +5299,8 @@ inline static void _slurm_rpc_reboot_nodes(slurm_msg_t * msg)
 
 inline static void  _slurm_rpc_accounting_first_reg(slurm_msg_t *msg)
 {
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	time_t event_time = time(NULL);
 
 	DEF_TIMERS;
@@ -5257,7 +5320,8 @@ inline static void  _slurm_rpc_accounting_first_reg(slurm_msg_t *msg)
 
 inline static void  _slurm_rpc_accounting_register_ctld(slurm_msg_t *msg)
 {
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	DEF_TIMERS;
 
@@ -5284,7 +5348,8 @@ inline static void _slurm_rpc_dump_spank(slurm_msg_t * msg)
 	/* Locks: read job */
 	slurmctld_lock_t job_read_lock = {
 		NO_LOCK, READ_LOCK, NO_LOCK, NO_LOCK };
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 	slurm_msg_t response_msg;
 	DEF_TIMERS;
 
@@ -5393,7 +5458,8 @@ inline static void _slurm_rpc_dump_stats(slurm_msg_t * msg)
 	int dump_size;
 	stats_info_request_msg_t *request_msg;
 	slurm_msg_t response_msg;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	request_msg = (stats_info_request_msg_t *)msg->data;
 
@@ -5444,7 +5510,8 @@ _slurm_rpc_dump_licenses(slurm_msg_t * msg)
 	int dump_size;
 	slurm_msg_t response_msg;
 	license_info_request_msg_t  *lic_req_msg;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("%s: Processing RPC: REQUEST_LICENSE_INFO uid=%d",
@@ -5514,7 +5581,8 @@ _slurm_rpc_kill_job2(slurm_msg_t *msg)
 	int cc;
 
 	kill =	(job_step_kill_msg_t *)msg->data;
-	uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid = g_slurm_auth_get_uid(msg->auth_cred,
+				   slurmctld_config.auth_info);
 
 	START_TIMER;
 	info("%s: REQUEST_KILL_JOB job %s uid %d",
@@ -5777,7 +5845,8 @@ static void _slurm_rpc_assoc_mgr_info(slurm_msg_t * msg)
 	char *dump = NULL;
 	int dump_size = 0;
 	slurm_msg_t response_msg;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred,
+					 slurmctld_config.auth_info);
 
 	START_TIMER;
 	debug2("%s: Processing RPC: REQUEST_ASSOC_MGR_INFO uid=%d",
diff --git a/src/slurmctld/read_config.c b/src/slurmctld/read_config.c
index 7689349ae7563175a645df81bc17534929ef00fa..231efd3decdaa215a705d522f988a6cdc76b363e 100644
--- a/src/slurmctld/read_config.c
+++ b/src/slurmctld/read_config.c
@@ -884,6 +884,8 @@ int read_slurm_conf(int recover, bool reconfig)
 	/* initialization */
 	START_TIMER;
 
+	xfree(slurmctld_config.auth_info);
+	slurmctld_config.auth_info = slurm_get_auth_info();
 	if (reconfig) {
 		/* in order to re-use job state information,
 		 * update nodes_completing string (based on node bitmaps) */
diff --git a/src/slurmctld/slurmctld.h b/src/slurmctld/slurmctld.h
index 96a2c1cadafc0fae0a3c9e55fbddffa8f944af66..6e3b65ab83a55d17149493dc97f65443521975cc 100644
--- a/src/slurmctld/slurmctld.h
+++ b/src/slurmctld/slurmctld.h
@@ -132,12 +132,13 @@
 \*****************************************************************************/
 
 typedef struct slurmctld_config {
+	char *	auth_info;
+	time_t	boot_time;
 	int	daemonize;
 	bool	resume_backup;
-	time_t	boot_time;
-	time_t	shutdown_time;
+	bool    scheduling_disabled;
 	int	server_thread_count;
-	bool scheduling_disabled;
+	time_t	shutdown_time;
 
 	slurm_cred_ctx_t cred_ctx;
 	pthread_mutex_t thread_count_lock;
diff --git a/src/slurmd/slurmd/req.c b/src/slurmd/slurmd/req.c
index f173ab415c98cfc2d27476b61eb40e480e306ef0..c3033cf24152c94ffda7c8461fc665ff972ca69e 100644
--- a/src/slurmd/slurmd/req.c
+++ b/src/slurmd/slurmd/req.c
@@ -1228,7 +1228,7 @@ _rpc_launch_tasks(slurm_msg_t *msg)
 	/* It is always 0 for front end systems */
 	nodeid = nodelist_find(req->complete_nodelist, conf->node_name);
 #endif
-	req_uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 	memcpy(&req->orig_addr, &msg->orig_addr, sizeof(slurm_addr_t));
 
 	super_user = _slurm_authorized_user(req_uid);
@@ -1787,7 +1787,7 @@ static void _rpc_prolog(slurm_msg_t *msg)
 	if (req == NULL)
 		return;
 
-	req_uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 	if (!_slurm_authorized_user(req_uid)) {
 		error("REQUEST_LAUNCH_PROLOG request from uid %u",
 		      (unsigned int) req_uid);
@@ -1878,7 +1878,7 @@ _rpc_batch_job(slurm_msg_t *msg, bool new_msg)
 
 	if (new_msg) {
 		uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-						     slurm_get_auth_info());
+						     conf->auth_info);
 		if (!_slurm_authorized_user(req_uid)) {
 			error("Security violation, batch launch RPC from uid %d",
 			      req_uid);
@@ -2083,7 +2083,7 @@ _rpc_job_notify(slurm_msg_t *msg)
 {
 	job_notify_msg_t *req = msg->data;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 	uid_t job_uid;
 	List steps;
 	ListIterator i;
@@ -2226,7 +2226,7 @@ static void
 _rpc_reconfig(slurm_msg_t *msg)
 {
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 
 	if (!_slurm_authorized_user(req_uid))
 		error("Security violation, reconfig RPC from uid %d",
@@ -2241,7 +2241,7 @@ static void
 _rpc_shutdown(slurm_msg_t *msg)
 {
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 
 	forward_wait(msg);
 	if (!_slurm_authorized_user(req_uid))
@@ -2262,7 +2262,7 @@ _rpc_reboot(slurm_msg_t *msg)
 	reboot_msg_t *reboot_msg;
 	slurm_ctl_conf_t *cfg;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 	int exit_code;
 
 	if (!_slurm_authorized_user(req_uid))
@@ -2574,7 +2574,7 @@ _rpc_ping(slurm_msg_t *msg)
 {
 	int        rc = SLURM_SUCCESS;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 	static bool first_msg = true;
 
 	if (!_slurm_authorized_user(req_uid)) {
@@ -2625,7 +2625,7 @@ _rpc_health_check(slurm_msg_t *msg)
 {
 	int        rc = SLURM_SUCCESS;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 
 	if (!_slurm_authorized_user(req_uid)) {
 		error("Security violation, health check RPC from uid %d",
@@ -2661,7 +2661,7 @@ _rpc_acct_gather_update(slurm_msg_t *msg)
 {
 	int        rc = SLURM_SUCCESS;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 	static bool first_msg = true;
 
 	if (!_slurm_authorized_user(req_uid)) {
@@ -2718,7 +2718,7 @@ _rpc_acct_gather_energy(slurm_msg_t *msg)
 {
 	int        rc = SLURM_SUCCESS;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 	static bool first_msg = true;
 
 	if (!_slurm_authorized_user(req_uid)) {
@@ -2824,7 +2824,7 @@ _rpc_signal_tasks(slurm_msg_t *msg)
 {
 	int               rc = SLURM_SUCCESS;
 	uid_t             req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-							 slurm_get_auth_info());
+							 conf->auth_info);
 	kill_tasks_msg_t *req = (kill_tasks_msg_t *) msg->data;
 	uint32_t flag;
 	uint32_t sig;
@@ -2855,7 +2855,7 @@ _rpc_checkpoint_tasks(slurm_msg_t *msg)
 	int               fd;
 	int               rc = SLURM_SUCCESS;
 	uid_t             req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-							 slurm_get_auth_info());
+							 conf->auth_info);
 	checkpoint_tasks_msg_t *req = (checkpoint_tasks_msg_t *) msg->data;
 	uint16_t protocol_version;
 	uid_t uid;
@@ -2922,7 +2922,7 @@ _rpc_terminate_tasks(slurm_msg_t *msg)
 		goto done2;
 	}
 
-	req_uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 	if ((req_uid != uid)
 	    && (!_slurm_authorized_user(req_uid))) {
 		debug("kill req from uid %ld for job %u.%u owned by uid %ld",
@@ -2963,7 +2963,7 @@ _rpc_step_complete(slurm_msg_t *msg)
 
 	/* step completion messages are only allowed from other slurmstepd,
 	   so only root or SlurmUser is allowed here */
-	req_uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 	if (!_slurm_authorized_user(req_uid)) {
 		debug("step completion from uid %ld for job %u.%u",
 		      (long) req_uid, req->job_id, req->job_step_id);
@@ -2997,7 +2997,7 @@ static int
 _rpc_step_complete_aggr(slurm_msg_t *msg)
 {
 	int rc;
-	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	uid_t uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 
 	if (!_slurm_authorized_user(uid)) {
 		error("Security violation: step_complete_aggr from uid %d",
@@ -3125,7 +3125,7 @@ _rpc_stat_jobacct(slurm_msg_t *msg)
 	debug3("Entering _rpc_stat_jobacct");
 	/* step completion messages are only allowed from other slurmstepd,
 	   so only root or SlurmUser is allowed here */
-	req_uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 
 	fd = stepd_connect(conf->spooldir, conf->node_name,
 			   req->job_id, req->step_id, &protocol_version);
@@ -3258,7 +3258,7 @@ _rpc_network_callerid(slurm_msg_t *msg)
 	rc = _callerid_find_job(conn, &job_id);
 	if (rc == SLURM_SUCCESS) {
 		/* We found the job */
-		req_uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+		req_uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 		if (!_slurm_authorized_user(req_uid)) {
 			/* Requestor is not root or SlurmUser */
 			job_uid = _get_job_uid(job_id);
@@ -3298,7 +3298,7 @@ _rpc_list_pids(slurm_msg_t *msg)
 	debug3("Entering _rpc_list_pids");
 	/* step completion messages are only allowed from other slurmstepd,
 	 * so only root or SlurmUser is allowed here */
-	req_uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 
 	job_uid = _get_job_uid(req->job_id);
 
@@ -3365,7 +3365,7 @@ static void
 _rpc_timelimit(slurm_msg_t *msg)
 {
 	uid_t           uid = g_slurm_auth_get_uid(msg->auth_cred,
-						   slurm_get_auth_info());
+						   conf->auth_info);
 	kill_job_msg_t *req = msg->data;
 	int             nsteps, rc;
 
@@ -3667,8 +3667,8 @@ static int _rpc_file_bcast(slurm_msg_t *msg)
 	file_bcast_msg_t *req = msg->data;
 	file_bcast_info_t key;
 
-	key.uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
-	key.gid = g_slurm_auth_get_gid(msg->auth_cred, slurm_get_auth_info());
+	key.uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
+	key.gid = g_slurm_auth_get_gid(msg->auth_cred, conf->auth_info);
 	key.fname = req->fname;
 
 	rc = _valid_sbcast_cred(req, key.uid, req->block_no, &key.job_id);
@@ -3971,7 +3971,7 @@ _rpc_reattach_tasks(slurm_msg_t *msg)
 
 	debug2("_rpc_reattach_tasks: nodeid %d in the job step", nodeid);
 
-	req_uid = g_slurm_auth_get_uid(msg->auth_cred, slurm_get_auth_info());
+	req_uid = g_slurm_auth_get_uid(msg->auth_cred, conf->auth_info);
 	if ((req_uid != uid) && (!_slurm_authorized_user(req_uid))) {
 		error("uid %ld attempt to attach to job %u.%u owned by %ld",
 		      (long) req_uid, req->job_id, req->job_step_id,
@@ -4340,7 +4340,7 @@ _rpc_signal_job(slurm_msg_t *msg)
 {
 	signal_job_msg_t *req = msg->data;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 	uid_t job_uid;
 	List steps;
 	ListIterator i;
@@ -4504,7 +4504,7 @@ _rpc_suspend_job(slurm_msg_t *msg)
 	int time_slice = -1;
 	suspend_int_msg_t *req = msg->data;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 	List steps;
 	ListIterator i;
 	step_loc_t *stepd;
@@ -4705,7 +4705,7 @@ _rpc_abort_job(slurm_msg_t *msg)
 {
 	kill_job_msg_t *req    = msg->data;
 	uid_t           uid    = g_slurm_auth_get_uid(msg->auth_cred,
-						      slurm_get_auth_info());
+						      conf->auth_info);
 	job_env_t       job_env;
 
 	debug("_rpc_abort_job, uid = %d", uid);
@@ -4925,7 +4925,7 @@ _rpc_complete_batch(slurm_msg_t *msg)
 	int		i, rc, msg_rc;
 	slurm_msg_t	resp_msg;
 	uid_t           uid    = g_slurm_auth_get_uid(msg->auth_cred,
-						      slurm_get_auth_info());
+						      conf->auth_info);
 	complete_batch_script_msg_t *req = msg->data;
 	static int	running_serial = -1;
 	uint16_t msg_type;
@@ -5008,7 +5008,7 @@ _rpc_terminate_job(slurm_msg_t *msg)
 	int             rc     = SLURM_SUCCESS;
 	kill_job_msg_t *req    = msg->data;
 	uid_t           uid    = g_slurm_auth_get_uid(msg->auth_cred,
-						      slurm_get_auth_info());
+						      conf->auth_info);
 	int             nsteps = 0;
 	int		delay;
 //	slurm_ctl_conf_t *cf;
@@ -5405,7 +5405,7 @@ _rpc_update_time(slurm_msg_t *msg)
 {
 	int   rc      = SLURM_SUCCESS;
 	uid_t req_uid = g_slurm_auth_get_uid(msg->auth_cred,
-					     slurm_get_auth_info());
+					     conf->auth_info);
 
 	if ((req_uid != conf->slurm_user_id) && (req_uid != 0)) {
 		rc = ESLURM_USER_ID_MISSING;
@@ -6246,7 +6246,7 @@ _rpc_forward_data(slurm_msg_t *msg)
 	}
 
 	req_uid = (uint32_t)g_slurm_auth_get_uid(msg->auth_cred,
-						 slurm_get_auth_info());
+						 conf->auth_info);
 	/*
 	 * although always in localhost, we still convert it to network
 	 * byte order, to make it consistent with pack/unpack.
diff --git a/src/slurmd/slurmd/slurmd.c b/src/slurmd/slurmd/slurmd.c
index 6165d40568d2d977a2442355560f128902c37336..3009ab15c41f9950dd40807a3d0907ef80151b7e 100644
--- a/src/slurmd/slurmd/slurmd.c
+++ b/src/slurmd/slurmd/slurmd.c
@@ -813,6 +813,10 @@ _read_config(void)
 	slurm_mutex_lock(&conf->config_mutex);
 	cf = slurm_conf_lock();
 
+	xfree(conf->auth_info);
+	conf->auth_info = xstrdup(cf->authinfo);
+
+	xfree(conf->chos_loc);
 	conf->chos_loc = xstrdup(cf->chos_loc);
 
 	conf->last_update = time(NULL);
diff --git a/src/slurmd/slurmd/slurmd.h b/src/slurmd/slurmd/slurmd.h
index 49899c0f3cddb1bef50939b1c92dbb1fa2ec1c7e..454b4d79572a736ca7fb6dcd7ba94f5e98d90f93 100644
--- a/src/slurmd/slurmd/slurmd.h
+++ b/src/slurmd/slurmd/slurmd.h
@@ -70,6 +70,7 @@ typedef struct slurmd_config {
 	char         *prog;		/* Program basename		   */
 	char         ***argv;           /* pointer to argument vector      */
 	int          *argc;             /* pointer to argument count       */
+	char         *auth_info;	/* AuthInfo for msg authentication */ 
 	char         *chos_loc;		/* Chroot OS wrapper path          */
 	char         *cluster_name; 	/* conf ClusterName		   */
 	char         *hostname;	 	/* local hostname		   */
diff --git a/src/slurmd/slurmstepd/req.c b/src/slurmd/slurmstepd/req.c
index a9723a25ef1b285b4445a9b87dd1c61168dc0e1b..147a6f0f57d169cbb2d4ccfbfda7cda865b0cb51 100644
--- a/src/slurmd/slurmstepd/req.c
+++ b/src/slurmd/slurmstepd/req.c
@@ -401,6 +401,7 @@ _handle_accept(void *arg)
 	int rc;
 	uid_t uid;
 	gid_t gid;
+	char *auth_info;
 
 	debug3("Entering _handle_accept (new thread)");
 	xfree(arg);
@@ -423,18 +424,21 @@ _handle_accept(void *arg)
 		free_buf(buffer);
 		goto fail;
 	}
-	rc = g_slurm_auth_verify(auth_cred, NULL, 2, slurm_get_auth_info());
+	auth_info = slurm_get_auth_info();
+	rc = g_slurm_auth_verify(auth_cred, NULL, 2, auth_info);
 	if (rc != SLURM_SUCCESS) {
 		error("Verifying authentication credential: %s",
 		      g_slurm_auth_errstr(g_slurm_auth_errno(auth_cred)));
+		xfree(auth_info);
 		(void) g_slurm_auth_destroy(auth_cred);
 		free_buf(buffer);
 		goto fail;
 	}
 
 	/* Get the uid & gid from the credential, then destroy it. */
-	uid = g_slurm_auth_get_uid(auth_cred, slurm_get_auth_info());
-	gid = g_slurm_auth_get_gid(auth_cred, slurm_get_auth_info());
+	uid = g_slurm_auth_get_uid(auth_cred, auth_info);
+	gid = g_slurm_auth_get_gid(auth_cred, auth_info);
+	xfree(auth_info);
 	debug3("  Identity: uid=%d, gid=%d", uid, gid);
 	g_slurm_auth_destroy(auth_cred);
 	free_buf(buffer);