From 860aa5dcb8ae7bf0ca2894345844e571a3e60a96 Mon Sep 17 00:00:00 2001
From: Moe Jette <jette1@llnl.gov>
Date: Fri, 15 Nov 2002 00:17:09 +0000
Subject: [PATCH] General API code cleanup. All free message functions to be
 used by users moved from common into api directory.

---
 src/api/Makefile.am              |   1 +
 src/api/cancel.c                 |  17 +-
 src/api/complete.c               |  15 +-
 src/api/config_info.c            |  89 +++++---
 src/api/free_msg.c               | 342 +++++++++++++++++++++++++++++++
 src/api/job_info.c               |  14 +-
 src/api/job_step_info.c          |   6 +-
 src/api/node_info.c              |   6 +-
 src/api/partition_info.c         |   6 +-
 src/api/reconfigure.c            |  11 +-
 src/api/slurm.h                  | 103 +++++++---
 src/api/submit.c                 |   6 +-
 src/api/update_config.c          |  12 +-
 src/common/slurm_protocol_defs.c | 245 ----------------------
 src/common/slurm_protocol_defs.h |  28 ---
 15 files changed, 532 insertions(+), 369 deletions(-)
 create mode 100644 src/api/free_msg.c

diff --git a/src/api/Makefile.am b/src/api/Makefile.am
index 48132395253..62833b9658b 100644
--- a/src/api/Makefile.am
+++ b/src/api/Makefile.am
@@ -15,6 +15,7 @@ libslurm_la_SOURCES =    \
 	cancel.c         \
 	complete.c       \
 	config_info.c    \
+	free_msg.c       \
 	job_info.c       \
 	job_step_info.c  \
 	node_info.c      \
diff --git a/src/api/cancel.c b/src/api/cancel.c
index f555daa2b9d..b222e18bb0f 100644
--- a/src/api/cancel.c
+++ b/src/api/cancel.c
@@ -42,7 +42,7 @@ slurm_cancel_job ( uint32_t job_id )
 	return slurm_cancel_job_step ( job_id, NO_VAL);
 }
 
-/* slurm_cancel_job_step - cancel a specific job step (or all steps if step_id==NO_VAL) */
+/* slurm_cancel_job_step - cancel a specific job step */
 int 
 slurm_cancel_job_step ( uint32_t job_id, uint32_t step_id  )
 {
@@ -55,7 +55,8 @@ slurm_cancel_job_step ( uint32_t job_id, uint32_t step_id  )
 	return_code_msg_t * slurm_rc_msg ;
 
 	/* init message connection for message communication with controller */
-	if ( ( sockfd = slurm_open_controller_conn ( ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( sockfd = slurm_open_controller_conn ( ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_CONNECTION_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
@@ -65,19 +66,22 @@ slurm_cancel_job_step ( uint32_t job_id, uint32_t step_id  )
 	job_step_id_msg . job_step_id = step_id ;
 	request_msg . msg_type = REQUEST_CANCEL_JOB_STEP ;
 	request_msg . data = &job_step_id_msg ;
-	if ( ( rc = slurm_send_controller_msg ( sockfd , & request_msg ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( rc = slurm_send_controller_msg ( sockfd , & request_msg ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_SEND_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
 
 	/* receive message */
-	if ( ( msg_size = slurm_receive_msg ( sockfd , & response_msg ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( msg_size = slurm_receive_msg ( sockfd , & response_msg ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_RECEIVE_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
 
 	/* shutdown message connection */
-	if ( ( rc = slurm_shutdown_msg_conn ( sockfd ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( rc = slurm_shutdown_msg_conn ( sockfd ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_SHUTDOWN_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
@@ -87,7 +91,8 @@ slurm_cancel_job_step ( uint32_t job_id, uint32_t step_id  )
 	switch ( response_msg . msg_type )
 	{
 		case RESPONSE_SLURM_RC:
-			slurm_rc_msg = ( return_code_msg_t * ) response_msg . data ;
+			slurm_rc_msg = 
+				( return_code_msg_t * ) response_msg . data ;
 			rc = slurm_rc_msg->return_code;
 			slurm_free_return_code_msg ( slurm_rc_msg );	
 			if (rc) {
diff --git a/src/api/complete.c b/src/api/complete.c
index 4716bd357f2..e3eeea122a3 100644
--- a/src/api/complete.c
+++ b/src/api/complete.c
@@ -56,7 +56,8 @@ slurm_complete_job_step ( uint32_t job_id, uint32_t step_id  )
 	return_code_msg_t * slurm_rc_msg ;
 
 	/* init message connection for message communication with controller */
-	if ( ( sockfd = slurm_open_controller_conn ( ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( sockfd = slurm_open_controller_conn ( ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_CONNECTION_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
@@ -66,19 +67,22 @@ slurm_complete_job_step ( uint32_t job_id, uint32_t step_id  )
 	job_step_id_msg . job_step_id = step_id ;
 	request_msg . msg_type = REQUEST_COMPLETE_JOB_STEP ;
 	request_msg . data = &job_step_id_msg ;
-	if ( ( rc = slurm_send_controller_msg ( sockfd , & request_msg ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( rc = slurm_send_controller_msg ( sockfd , & request_msg ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_SEND_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
 
 	/* receive message */
-	if ( ( msg_size = slurm_receive_msg ( sockfd , & response_msg ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( msg_size = slurm_receive_msg ( sockfd , & response_msg ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_RECEIVE_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
 
 	/* shutdown message connection */
-	if ( ( rc = slurm_shutdown_msg_conn ( sockfd ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( rc = slurm_shutdown_msg_conn ( sockfd ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_SHUTDOWN_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
@@ -88,7 +92,8 @@ slurm_complete_job_step ( uint32_t job_id, uint32_t step_id  )
 	switch ( response_msg . msg_type )
 	{
 		case RESPONSE_SLURM_RC:
-			slurm_rc_msg = ( return_code_msg_t * ) response_msg . data ;
+			slurm_rc_msg = 
+				( return_code_msg_t * ) response_msg . data ;
 			rc = slurm_rc_msg->return_code;
 			slurm_free_return_code_msg ( slurm_rc_msg );	
 			if (rc) {
diff --git a/src/api/config_info.c b/src/api/config_info.c
index 5234e374466..af078c17cbd 100644
--- a/src/api/config_info.c
+++ b/src/api/config_info.c
@@ -46,36 +46,58 @@ void slurm_print_ctl_conf ( FILE* out, slurm_ctl_conf_info_msg_t * slurm_ctl_con
 
 	make_time_str ((time_t *)&slurm_ctl_conf_ptr->last_update, time_str);
 	fprintf(out, "Configuration updated at %s\n", time_str);
-	fprintf(out, "BackupAddr        = %s\n", slurm_ctl_conf_ptr->backup_addr);
-	fprintf(out, "BackupController  = %s\n", slurm_ctl_conf_ptr->backup_controller);
-	fprintf(out, "ControlAddr       = %s\n", slurm_ctl_conf_ptr->control_addr);
-	fprintf(out, "ControlMachine    = %s\n", slurm_ctl_conf_ptr->control_machine);
-	fprintf(out, "Epilog            = %s\n", slurm_ctl_conf_ptr->epilog);
-	fprintf(out, "FastSchedule      = %u\n", slurm_ctl_conf_ptr->fast_schedule);
-	fprintf(out, "NodeHashBase      = %u\n", slurm_ctl_conf_ptr->hash_base);
-	fprintf(out, "HeartbeatInterval = %u\n", slurm_ctl_conf_ptr->heartbeat_interval);
-	fprintf(out, "InactiveLimit     = %u\n", slurm_ctl_conf_ptr->inactive_limit);
-	fprintf(out, "KillWait          = %u\n", slurm_ctl_conf_ptr->kill_wait);
-	fprintf(out, "Prioritize        = %s\n", slurm_ctl_conf_ptr->prioritize);
-	fprintf(out, "Prolog            = %s\n", slurm_ctl_conf_ptr->prolog);
-	fprintf(out, "ReturnToService   = %u\n", slurm_ctl_conf_ptr->ret2service);
-	fprintf(out, "SlurmctldLogFile  = %s\n", slurm_ctl_conf_ptr->slurmctld_logfile);
-	fprintf(out, "SlurmctldTimeout  = %u\n", slurm_ctl_conf_ptr->slurmctld_timeout);
-	fprintf(out, "SlurmdLogFile     = %s\n", slurm_ctl_conf_ptr->slurmd_logfile);
-	fprintf(out, "SlurmdSpoolDir    = %s\n", slurm_ctl_conf_ptr->slurmd_spooldir);
-	fprintf(out, "SlurmdTimeout     = %u\n", slurm_ctl_conf_ptr->slurmd_timeout);
-	fprintf(out, "SLURM_CONFIG_FILE = %s\n", slurm_ctl_conf_ptr->slurm_conf);
-	fprintf(out, "StateSaveLocation = %s\n", slurm_ctl_conf_ptr->state_save_location);
-	fprintf(out, "TmpFS             = %s\n", slurm_ctl_conf_ptr->tmp_fs);
+	fprintf(out, "BackupAddr        = %s\n", 
+		slurm_ctl_conf_ptr->backup_addr);
+	fprintf(out, "BackupController  = %s\n", 
+		slurm_ctl_conf_ptr->backup_controller);
+	fprintf(out, "ControlAddr       = %s\n", 
+		slurm_ctl_conf_ptr->control_addr);
+	fprintf(out, "ControlMachine    = %s\n", 
+		slurm_ctl_conf_ptr->control_machine);
+	fprintf(out, "Epilog            = %s\n", 
+		slurm_ctl_conf_ptr->epilog);
+	fprintf(out, "FastSchedule      = %u\n", 
+		slurm_ctl_conf_ptr->fast_schedule);
+	fprintf(out, "NodeHashBase      = %u\n", 
+		slurm_ctl_conf_ptr->hash_base);
+	fprintf(out, "HeartbeatInterval = %u\n", 
+		slurm_ctl_conf_ptr->heartbeat_interval);
+	fprintf(out, "InactiveLimit     = %u\n", 
+		slurm_ctl_conf_ptr->inactive_limit);
+	fprintf(out, "KillWait          = %u\n", 
+		slurm_ctl_conf_ptr->kill_wait);
+	fprintf(out, "Prioritize        = %s\n", 
+		slurm_ctl_conf_ptr->prioritize);
+	fprintf(out, "Prolog            = %s\n", 
+		slurm_ctl_conf_ptr->prolog);
+	fprintf(out, "ReturnToService   = %u\n", 
+		slurm_ctl_conf_ptr->ret2service);
+	fprintf(out, "SlurmctldLogFile  = %s\n", 
+		slurm_ctl_conf_ptr->slurmctld_logfile);
+	fprintf(out, "SlurmctldTimeout  = %u\n", 
+		slurm_ctl_conf_ptr->slurmctld_timeout);
+	fprintf(out, "SlurmdLogFile     = %s\n", 
+		slurm_ctl_conf_ptr->slurmd_logfile);
+	fprintf(out, "SlurmdSpoolDir    = %s\n", 
+		slurm_ctl_conf_ptr->slurmd_spooldir);
+	fprintf(out, "SlurmdTimeout     = %u\n", 
+		slurm_ctl_conf_ptr->slurmd_timeout);
+	fprintf(out, "SLURM_CONFIG_FILE = %s\n", 
+		slurm_ctl_conf_ptr->slurm_conf);
+	fprintf(out, "StateSaveLocation = %s\n", 
+		slurm_ctl_conf_ptr->state_save_location);
+	fprintf(out, "TmpFS             = %s\n", 
+		slurm_ctl_conf_ptr->tmp_fs);
 }
 
 /*
- * slurm_load_ctl_conf - issue RPC to get slurm controlconfiguration information 
- *	if changed since update_time 
+ * slurm_load_ctl_conf - issue RPC to get slurm control configuration  
+ *	information if changed since update_time 
  * NOTE: free the response using slurm_free_ctl_conf
  */
 int
-slurm_load_ctl_conf (time_t update_time, slurm_ctl_conf_t **slurm_ctl_conf_ptr )
+slurm_load_ctl_conf (time_t update_time, 
+			slurm_ctl_conf_t **slurm_ctl_conf_ptr )
 {
 	int msg_size ;
 	int rc ;
@@ -86,7 +108,8 @@ slurm_load_ctl_conf (time_t update_time, slurm_ctl_conf_t **slurm_ctl_conf_ptr )
 	return_code_msg_t * slurm_rc_msg ;
 	
         /* init message connection for message communication with controller */
-	if ( ( sockfd = slurm_open_controller_conn ( ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( sockfd = slurm_open_controller_conn ( ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_CONNECTION_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
@@ -94,17 +117,20 @@ slurm_load_ctl_conf (time_t update_time, slurm_ctl_conf_t **slurm_ctl_conf_ptr )
 	last_time_msg . last_update = update_time ;
 	request_msg . msg_type = REQUEST_BUILD_INFO ;
 	request_msg . data = &last_time_msg ;
-	if ( ( rc = slurm_send_controller_msg ( sockfd , & request_msg ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( rc = slurm_send_controller_msg ( sockfd , & request_msg ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_SEND_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
 	
 	/* receive message */
-	if ( ( msg_size = slurm_receive_msg ( sockfd , & response_msg ) ) == SLURM_SOCKET_ERROR )
+	if ( ( msg_size = slurm_receive_msg ( sockfd , & response_msg ) )
+			 == SLURM_SOCKET_ERROR )
 		return SLURM_SOCKET_ERROR ;
 	
 	/* shutdown message connection */
-	if ( ( rc = slurm_shutdown_msg_conn ( sockfd ) ) == SLURM_SOCKET_ERROR )
+	if ( ( rc = slurm_shutdown_msg_conn ( sockfd ) ) 
+			== SLURM_SOCKET_ERROR )
 		return SLURM_SOCKET_ERROR ;	
 	if ( msg_size )
 		return msg_size;
@@ -112,11 +138,14 @@ slurm_load_ctl_conf (time_t update_time, slurm_ctl_conf_t **slurm_ctl_conf_ptr )
 	switch ( response_msg . msg_type )
         {
                 case RESPONSE_BUILD_INFO:
-                        *slurm_ctl_conf_ptr = ( slurm_ctl_conf_info_msg_t * ) response_msg . data ; 
+                        *slurm_ctl_conf_ptr = 
+				( slurm_ctl_conf_info_msg_t * )
+				response_msg . data ; 
         		return SLURM_PROTOCOL_SUCCESS ;
                         break ;
 		case RESPONSE_SLURM_RC:
-			slurm_rc_msg = ( return_code_msg_t * ) response_msg . data ;
+			slurm_rc_msg = 
+				( return_code_msg_t * ) response_msg . data ;
 			rc = slurm_rc_msg->return_code;
 			slurm_free_return_code_msg ( slurm_rc_msg );	
 			if (rc) {
diff --git a/src/api/free_msg.c b/src/api/free_msg.c
new file mode 100644
index 00000000000..180d16cc682
--- /dev/null
+++ b/src/api/free_msg.c
@@ -0,0 +1,342 @@
+/*****************************************************************************\
+ *  free_msg.c - free RPC response messages including all allocated memory
+ *****************************************************************************
+ *  Copyright (C) 2002 The Regents of the University of California.
+ *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
+ *  Written by moe jette <jette1@llnl.gov>.
+ *  UCRL-CODE-2002-040.
+ *  
+ *  This file is part of SLURM, a resource management program.
+ *  For details, see <http://www.llnl.gov/linux/slurm/>.
+ *  
+ *  SLURM is free software; you can redistribute it and/or modify it under
+ *  the terms of the GNU General Public License as published by the Free
+ *  Software Foundation; either version 2 of the License, or (at your option)
+ *  any later version.
+ *  
+ *  SLURM is distributed in the hope that it will be useful, but WITHOUT ANY
+ *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ *  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+ *  details.
+ *  
+ *  You should have received a copy of the GNU General Public License along
+ *  with SLURM; if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+\*****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+
+#include <src/api/slurm.h>
+#include <src/common/slurm_protocol_api.h>
+#include <src/common/xmalloc.h>
+
+static void _free_all_job_info (job_info_msg_t *msg);
+static void _slurm_free_job_info_members (job_info_t * job);
+
+static void _free_all_node_info (node_info_msg_t *msg);
+static void _slurm_free_node_info_members (node_info_t * node);
+
+static void _free_all_partitions (partition_info_msg_t *msg);
+static void _slurm_free_partition_info_members (partition_info_t * part);
+
+static void _free_all_step_info (job_step_info_response_msg_t *msg);
+static void _slurm_free_job_step_info_members (job_step_info_t * msg);
+
+
+/*
+ * slurm_free_resource_allocation_response_msg - free slurm resource
+ *	allocation response message
+ * NOTE: buffer is loaded by slurm_allocate_resources
+ */
+void slurm_free_resource_allocation_response_msg ( 
+				resource_allocation_response_msg_t * msg)
+{
+	if (msg) {
+		if (msg->node_list)
+			xfree(msg->node_list);
+		if (msg->cpus_per_node)
+			xfree(msg->cpus_per_node);
+		if (msg->cpu_count_reps)
+			xfree(msg->cpu_count_reps);
+		if (msg->node_addr)
+			xfree(msg->node_addr);
+		xfree(msg);
+	}
+}
+
+
+/*
+ * slurm_free_resource_allocation_and_run_response_msg - free slurm 
+ *	resource allocation and run job step response message
+ * NOTE: buffer is loaded by slurm_allocate_resources_and_run
+ */
+void slurm_free_resource_allocation_and_run_response_msg ( 
+			resource_allocation_and_run_response_msg_t * msg)
+{
+	if (msg) {
+		if (msg->node_list)
+			xfree(msg->node_list);
+		if (msg->cpus_per_node)
+			xfree(msg->cpus_per_node);
+		if (msg->cpu_count_reps)
+			xfree(msg->cpu_count_reps);
+		if (msg->credentials)
+			xfree(msg->credentials);
+		if (msg->node_addr)
+			xfree(msg->node_addr);
+#		ifdef HAVE_LIBELAN3
+		qsw_free_jobinfo(msg->qsw_job);
+#		endif
+		xfree(msg);
+	}
+}
+
+
+/*
+ * slurm_free_job_step_create_response_msg - free slurm 
+ *	job step create response message
+ * NOTE: buffer is loaded by slurm_job_step_create
+ */
+void slurm_free_job_step_create_response_msg(
+		job_step_create_response_msg_t * msg)
+{
+	if (msg) {
+		if (msg->credentials)
+			xfree(msg->credentials);
+
+#		ifdef HAVE_LIBELAN3
+		qsw_free_jobinfo(msg->qsw_job);
+#		endif
+
+		xfree(msg);
+	}
+
+}
+
+
+/*
+ * slurm_free_submit_response_response_msg - free slurm 
+ *	job submit response message
+ * NOTE: buffer is loaded by slurm_submit_batch_job
+ */
+void slurm_free_submit_response_response_msg(submit_response_msg_t * msg)
+{
+	if (msg)
+		xfree(msg);
+}
+
+
+/*
+ * slurm_free_ctl_conf - free slurm control information response message
+ * NOTE: buffer is loaded by slurm_load_jobs
+ */
+void slurm_free_ctl_conf(slurm_ctl_conf_info_msg_t * config_ptr)
+{
+	if (config_ptr) {
+		if (config_ptr->backup_addr)
+			xfree(config_ptr->backup_addr);
+		if (config_ptr->backup_controller)
+			xfree(config_ptr->backup_controller);
+		if (config_ptr->control_addr)
+			xfree(config_ptr->control_addr);
+		if (config_ptr->control_machine)
+			xfree(config_ptr->control_machine);
+		if (config_ptr->epilog)
+			xfree(config_ptr->epilog);
+		if (config_ptr->prioritize)
+			xfree(config_ptr->prioritize);
+		if (config_ptr->prolog)
+			xfree(config_ptr->prolog);
+		if (config_ptr->slurmctld_logfile)
+			xfree(config_ptr->slurmctld_logfile);
+		if (config_ptr->slurmd_logfile)
+			xfree(config_ptr->slurmd_logfile);
+		if (config_ptr->slurmd_spooldir)
+			xfree(config_ptr->slurmd_spooldir);
+		if (config_ptr->slurm_conf)
+			xfree(config_ptr->slurm_conf);
+		if (config_ptr->state_save_location)
+			xfree(config_ptr->state_save_location);
+		if (config_ptr->tmp_fs)
+			xfree(config_ptr->tmp_fs);
+		xfree(config_ptr);
+	}
+}
+
+
+/*
+ * slurm_free_job_info - free the job information response message
+ * NOTE: buffer is loaded by slurm_load_job.
+ */
+void slurm_free_job_info_msg(job_info_msg_t * job_buffer_ptr)
+{
+	if (job_buffer_ptr) {
+		if (job_buffer_ptr->job_array) {
+			_free_all_job_info(job_buffer_ptr);
+			xfree(job_buffer_ptr->job_array);
+		}
+		xfree(job_buffer_ptr);
+	}
+}
+
+static void _free_all_job_info(job_info_msg_t *msg)
+{
+	int i;
+
+	if ((msg == NULL) ||
+	    (msg->job_array == NULL))
+		return;
+
+	for (i = 0; i < msg->record_count; i++)
+		_slurm_free_job_info_members (&msg->job_array[i]);
+}
+
+static void _slurm_free_job_info_members(job_info_t * job)
+{
+	if (job) {
+		if (job->nodes)
+			xfree(job->nodes);
+		if (job->partition)
+			xfree(job->partition);
+		if (job->name)
+			xfree(job->name);
+		if (job->node_inx)
+			xfree(job->node_inx);
+		if (job->req_nodes)
+			xfree(job->req_nodes);
+		if (job->features)
+			xfree(job->features);
+		xfree(job->req_node_inx);
+	}
+}
+
+
+/*
+ * slurm_free_job_step_info_response_msg - free the job step 
+ *	information response message
+ * NOTE: buffer is loaded by slurm_get_job_steps.
+ */
+void slurm_free_job_step_info_response_msg(job_step_info_response_msg_t *
+					   msg)
+{
+	if (msg != NULL) {
+		if (msg->job_steps != NULL) {
+			_free_all_step_info(msg);
+			xfree(msg->job_steps);
+		}
+		xfree(msg);
+	}
+}
+
+static void _free_all_step_info (job_step_info_response_msg_t *msg)
+{
+	int i;
+
+	if ((msg == NULL) ||
+	    (msg->job_steps == NULL))
+		return;
+
+	for (i = 0; i < msg->job_step_count; i++)
+		_slurm_free_job_step_info_members (&msg->job_steps[i]);
+}
+
+static void _slurm_free_job_step_info_members (job_step_info_t * msg)
+{
+	if (msg != NULL) {
+		if (msg->partition != NULL)
+			xfree(msg->partition);
+		if (msg->nodes != NULL)
+			xfree(msg->nodes);
+	}
+}
+
+
+/*
+ * slurm_free_node_info - free the node information response message
+ * NOTE: buffer is loaded by slurm_load_node.
+ */
+void slurm_free_node_info_msg(node_info_msg_t * msg)
+{
+	if (msg) {
+		if (msg->node_array) {
+			_free_all_node_info(msg);
+			xfree(msg->node_array);
+		}
+		xfree(msg);
+	}
+}
+
+static void _free_all_node_info(node_info_msg_t *msg)
+{
+	int i;
+
+	if ((msg == NULL) ||
+	    (msg->node_array == NULL))
+		return;
+	
+	for (i = 0; i < msg->record_count; i++) 
+		_slurm_free_node_info_members(&msg->node_array[i]);
+}
+
+static void _slurm_free_node_info_members(node_info_t * node)
+{
+	if (node) {
+		if (node->name)
+			xfree(node->name);
+		if (node->features)
+			xfree(node->features);
+		if (node->partition)
+			xfree(node->partition);
+	}
+}
+
+
+/*
+ * slurm_free_partition_info_msg - free the partition information 
+ *	response message
+ * NOTE: buffer is loaded by slurm_load_partitions
+ */
+void slurm_free_partition_info_msg(partition_info_msg_t * msg)
+{
+	if (msg) {
+		if (msg->partition_array) {
+			_free_all_partitions(msg);
+			xfree(msg->partition_array);
+		}
+		xfree(msg);
+	}
+}
+
+static void  _free_all_partitions(partition_info_msg_t *msg)
+{
+	int i;
+
+	if ((msg == NULL) ||
+	    (msg->partition_array == NULL))
+		return;
+
+	for (i = 0; i < msg->record_count; i++)
+		_slurm_free_partition_info_members(
+			&msg->partition_array[i]);
+
+}
+
+static void _slurm_free_partition_info_members(partition_info_t * part)
+{
+	if (part) {
+		if (part->name)
+			xfree(part->name);
+		if (part->allow_groups)
+			xfree(part->allow_groups);
+		if (part->nodes)
+			xfree(part->nodes);
+		if (part->node_inx)
+			xfree(part->node_inx);
+	}
+}
+
diff --git a/src/api/job_info.c b/src/api/job_info.c
index d7073049048..490fc70eef2 100644
--- a/src/api/job_info.c
+++ b/src/api/job_info.c
@@ -118,8 +118,9 @@ make_time_str (time_t *time, char *string)
 	struct tm time_tm;
 
 	localtime_r (time, &time_tm);
-	sprintf ( string, "%2.2u/%2.2u-%2.2u:%2.2u:%2.2u", (time_tm.tm_mon+1), 
-		time_tm.tm_mday, time_tm.tm_hour, time_tm.tm_min, time_tm.tm_sec);
+	sprintf ( string, "%2.2u/%2.2u-%2.2u:%2.2u:%2.2u", 
+		(time_tm.tm_mon+1), time_tm.tm_mday, 
+		time_tm.tm_hour, time_tm.tm_min, time_tm.tm_sec);
 }
 
 
@@ -140,7 +141,8 @@ slurm_load_jobs (time_t update_time, job_info_msg_t **job_info_msg_pptr)
 	return_code_msg_t * slurm_rc_msg ;
 
 	/* init message connection for message communication with controller */
-	if ( ( sockfd = slurm_open_controller_conn ( ) ) == SLURM_SOCKET_ERROR ) {
+	if ( ( sockfd = slurm_open_controller_conn ( ) ) 
+			== SLURM_SOCKET_ERROR ) {
 		slurm_seterrno ( SLURM_COMMUNICATIONS_CONNECTION_ERROR );
 		return SLURM_SOCKET_ERROR ;
 	}
@@ -174,11 +176,13 @@ slurm_load_jobs (time_t update_time, job_info_msg_t **job_info_msg_pptr)
 	switch ( response_msg . msg_type )
 	{
 		case RESPONSE_JOB_INFO:
-			*job_info_msg_pptr = (job_info_msg_t *) response_msg.data ;
+			*job_info_msg_pptr = 
+				(job_info_msg_t *) response_msg.data ;
 			return SLURM_PROTOCOL_SUCCESS ;
 			break ;
 		case RESPONSE_SLURM_RC:
-			slurm_rc_msg = (return_code_msg_t *) response_msg.data ;
+			slurm_rc_msg = 
+				(return_code_msg_t *) response_msg.data ;
 			rc = slurm_rc_msg->return_code;
 			slurm_free_return_code_msg ( slurm_rc_msg );	
 			if (rc) {
diff --git a/src/api/job_step_info.c b/src/api/job_step_info.c
index 5660860ddf5..c236f26c80e 100644
--- a/src/api/job_step_info.c
+++ b/src/api/job_step_info.c
@@ -3,7 +3,8 @@
  *****************************************************************************
  *  Copyright (C) 2002 The Regents of the University of California.
  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
- *  Written by Moe Jette <jette1@llnl.gov>, Joey Ekstrom <ekstrom1@llnl.gov> et. al.
+ *  Written by Moe Jette <jette1@llnl.gov>, Joey Ekstrom <ekstrom1@llnl.gov> 
+ *	et. al.
  *  UCRL-CODE-2002-040.
  *  
  *  This file is part of SLURM, a resource management program.
@@ -132,7 +133,8 @@ slurm_get_job_steps (time_t update_time, uint32_t job_id, uint32_t step_id,
 	{
 		case RESPONSE_JOB_STEP_INFO:
 			*step_response_pptr = 
-				(job_step_info_response_msg_t *) response_msg.data ;
+				(job_step_info_response_msg_t *) 
+				response_msg.data ;
 			return SLURM_PROTOCOL_SUCCESS ;
 			break ;
 		case RESPONSE_SLURM_RC:
diff --git a/src/api/node_info.c b/src/api/node_info.c
index dfa7ef80ca5..04520aab9fd 100644
--- a/src/api/node_info.c
+++ b/src/api/node_info.c
@@ -131,11 +131,13 @@ slurm_load_node (time_t update_time, node_info_msg_t **node_info_msg_pptr)
 	switch ( response_msg . msg_type )
 	{
 		case RESPONSE_NODE_INFO:
-        		*node_info_msg_pptr = ( node_info_msg_t * ) response_msg . data ;
+        		*node_info_msg_pptr = 
+				( node_info_msg_t * ) response_msg . data ;
 		        return SLURM_PROTOCOL_SUCCESS ;
 			break ;
 		case RESPONSE_SLURM_RC:
-			slurm_rc_msg = ( return_code_msg_t * ) response_msg . data ;
+			slurm_rc_msg = 
+				( return_code_msg_t * ) response_msg . data ;
 			rc = slurm_rc_msg->return_code;
 			slurm_free_return_code_msg ( slurm_rc_msg );	
 			if (rc) {
diff --git a/src/api/partition_info.c b/src/api/partition_info.c
index 9f7a515180e..1287c52521a 100644
--- a/src/api/partition_info.c
+++ b/src/api/partition_info.c
@@ -165,11 +165,13 @@ slurm_load_partitions (time_t update_time,
 	{
 		case RESPONSE_PARTITION_INFO:
         		*partition_info_msg_pptr = 
-				( partition_info_msg_t * ) response_msg . data ;
+				( partition_info_msg_t * ) 
+				response_msg . data ;
 			return SLURM_SUCCESS ;
 			break ;
 		case RESPONSE_SLURM_RC:
-			slurm_rc_msg = ( return_code_msg_t * ) response_msg . data ;
+			slurm_rc_msg = 
+				( return_code_msg_t * ) response_msg . data ;
 			rc = slurm_rc_msg->return_code;
 			slurm_free_return_code_msg ( slurm_rc_msg );	
 			if (rc) {
diff --git a/src/api/reconfigure.c b/src/api/reconfigure.c
index abdd2de3ea7..309fe08d749 100644
--- a/src/api/reconfigure.c
+++ b/src/api/reconfigure.c
@@ -37,7 +37,7 @@
 #include <src/api/slurm.h>
 #include <src/common/slurm_protocol_api.h>
 
-static int send_message_controller (	enum controller_id dest, 
+static int _send_message_controller (	enum controller_id dest, 
 					slurm_msg_t *request_msg );
 
 /*
@@ -89,7 +89,8 @@ slurm_reconfigure ( void )
 	switch ( response_msg . msg_type )
 	{
 		case RESPONSE_SLURM_RC:
-			slurm_rc_msg = (return_code_msg_t *) response_msg.data ;
+			slurm_rc_msg = 
+				(return_code_msg_t *) response_msg.data ;
 			rc = slurm_rc_msg->return_code;
 			slurm_free_return_code_msg ( slurm_rc_msg );	
 			if (rc) {
@@ -125,14 +126,14 @@ slurm_shutdown (uint16_t core)
 	request_msg . data = &shutdown_msg;
 
 	/* explicity send the message to both primary and backup controllers */
-	(void) send_message_controller ( SECONDARY_CONTROLLER, &request_msg );
-	rc = send_message_controller ( PRIMARY_CONTROLLER,   &request_msg );
+	(void) _send_message_controller ( SECONDARY_CONTROLLER, &request_msg );
+	rc = _send_message_controller ( PRIMARY_CONTROLLER,   &request_msg );
 
 	return rc;
 }
 
 int
-send_message_controller ( enum controller_id dest, slurm_msg_t *request_msg ) 
+_send_message_controller ( enum controller_id dest, slurm_msg_t *request_msg ) 
 {
 	int rc, msg_size ;
 	slurm_fd sockfd ;
diff --git a/src/api/slurm.h b/src/api/slurm.h
index c2396deb60a..65c9adf620c 100644
--- a/src/api/slurm.h
+++ b/src/api/slurm.h
@@ -42,15 +42,33 @@
 extern int slurm_allocate_resources (job_desc_msg_t * job_desc_msg , 
 		resource_allocation_response_msg_t ** job_alloc_resp_msg, 
 		int immediate ) ;
+
+/*
+ * slurm_free_resource_allocation_response_msg - free slurm resource
+ *	allocation response message
+ * NOTE: buffer is loaded by either slurm_allocate_resources or 
+ *	slurm_confirm_allocation
+ */
+extern void slurm_free_resource_allocation_response_msg (
+		resource_allocation_response_msg_t * msg);
+
 /*
  * slurm_allocate_resources_and_run - allocate resources for a job request and 
  *	initiate a job step
  * NOTE: free the response using 
  *	slurm_free_resource_allocation_and_run_response_msg
  */
-extern int slurm_allocate_resources_and_run (job_desc_msg_t * job_desc_msg , 			
+extern int slurm_allocate_resources_and_run (job_desc_msg_t * job_desc_msg,
 		resource_allocation_and_run_response_msg_t ** slurm_alloc_msg );
 
+/*
+ * slurm_free_resource_allocation_and_run_response_msg - free slurm 
+ *	resource allocation and run job step response message
+ * NOTE: buffer is loaded by slurm_allocate_resources_and_run
+ */
+extern void slurm_free_resource_allocation_and_run_response_msg ( 
+		resource_allocation_and_run_response_msg_t * msg);
+
 /*
  * slurm_confirm_allocation - confirm an existing resource allocation
  * NOTE: free the response using slurm_free_resource_allocation_response_msg
@@ -67,11 +85,29 @@ extern int slurm_job_step_create (
 		job_step_create_response_msg_t ** slurm_step_alloc_resp_msg );
 
 /*
- * slurm_submit_batch_job - issue RPC to submit a job for later execution
- * NOTE: free the response using slurm_free_submit_response_response_msg
+ * slurm_free_job_step_create_response_msg - free slurm 
+ *	job step create response message
+ * NOTE: buffer is loaded by slurm_job_step_create
+ */
+extern void slurm_free_job_step_create_response_msg ( 
+		job_step_create_response_msg_t *msg);
+
+/*
+ * slurm_submit_batch_job - issue RPC to submit a job for later 
+ *	execution
+ * NOTE: free the response using 
+ *	slurm_free_submit_response_response_msg
  */
 extern int slurm_submit_batch_job (job_desc_msg_t * job_desc_msg, 
-					submit_response_msg_t ** slurm_alloc_msg );
+		submit_response_msg_t ** slurm_alloc_msg );
+
+/*
+ * slurm_free_submit_response_response_msg - free slurm 
+ *	job submit response message
+ * NOTE: buffer is loaded by slurm_submit_batch_job
+ */
+extern void slurm_free_submit_response_response_msg (
+		submit_response_msg_t *msg);
 
 /*
  * slurm_job_will_run - determine if a job would execute immediately if 
@@ -119,6 +155,12 @@ extern void make_time_str (time_t *time, char *string);
 extern int slurm_load_ctl_conf (time_t update_time, 
 		slurm_ctl_conf_t  **slurm_ctl_conf_ptr);
 
+/*
+ * slurm_free_ctl_conf - free slurm control information response message
+ * NOTE: buffer is loaded by slurm_load_ctl_conf
+ */
+extern void slurm_free_ctl_conf (slurm_ctl_conf_t* slurm_ctl_conf_ptr);
+
 /*
  * slurm_print_ctl_conf - output the contents of slurm control configuration
  *	message as loaded using slurm_load_ctl_conf
@@ -139,6 +181,12 @@ extern void slurm_print_ctl_conf ( FILE * out,
 extern int slurm_load_jobs (time_t update_time, 
 		job_info_msg_t **job_info_msg_pptr);
 
+/*
+ * slurm_free_job_info - free the job information response message
+ * NOTE: buffer is loaded by slurm_load_job.
+ */
+extern void slurm_free_job_info_msg (job_info_msg_t * job_buffer_ptr);
+
 /*
  * slurm_print_job_info_msg - output information about all Slurm 
  *	jobs based upon message as loaded using slurm_load_jobs
@@ -174,6 +222,14 @@ extern int slurm_get_job_steps (time_t update_time, uint32_t job_id,
 		uint32_t step_id, 
 		job_step_info_response_msg_t **step_response_pptr);
 
+/*
+ * slurm_free_job_step_info_response_msg - free the job step 
+ *	information response message
+ * NOTE: buffer is loaded by slurm_get_job_steps.
+ */
+extern void slurm_free_job_step_info_response_msg (
+		job_step_info_response_msg_t * msg);
+
 /*
  * slurm_print_job_step_info_msg - output information about all Slurm 
  *	job steps based upon message as loaded using slurm_get_job_steps
@@ -200,6 +256,12 @@ extern void slurm_print_job_step_info ( FILE*, job_step_info_t * step_ptr );
 extern int slurm_load_node (time_t update_time, 
 		node_info_msg_t **node_info_msg_pptr);
 
+/*
+ * slurm_free_node_info_msg - free the node message information buffer
+ * NOTE: buffer is loaded by slurm_load_node.
+ */
+extern void slurm_free_node_info_msg (node_info_msg_t * node_buffer_ptr);
+
 /*
  * slurm_print_node_info_msg - output information about all Slurm nodes
  *	based upon message as loaded using slurm_load_node
@@ -232,6 +294,12 @@ extern int slurm_update_node ( update_node_msg_t * node_msg ) ;
 extern int slurm_load_partitions (time_t update_time, 
 		partition_info_msg_t **part_buffer_ptr);
 
+/*
+ * slurm_free_partition_info_msg - free the partition information buffer
+ * NOTE: buffer is loaded by slurm_load_partitions
+ */
+extern void slurm_free_partition_info_msg ( partition_info_msg_t * part_info_ptr);
+
 /*
  * slurm_print_partition_info_msg - output information about all Slurm 
  *	partitions based upon message as loaded using slurm_load_partitions
@@ -271,32 +339,5 @@ extern int slurm_reconfigure ( void );
  */
 extern int slurm_shutdown (uint16_t core);
 
-
-
-
-
-
-
-
-extern void slurm_free_ctl_conf ( slurm_ctl_conf_t* slurm_ctl_conf_ptr);
-
-/*
- * slurm_free_job_info - free the job information buffer (if allocated)
- * NOTE: buffer is loaded by slurm_load_job.
- */
-extern void slurm_free_job_info_msg (job_info_msg_t * job_buffer_ptr);
-
-/*
- * slurm_free_node_info - free the node information buffer (if allocated)
- * NOTE: buffer is loaded by slurm_load_node.
- */
-extern void slurm_free_node_info_msg (node_info_msg_t * node_buffer_ptr);
-
-/*
- * slurm_free_part_info - free the partition information buffer (if allocated)
- * NOTE: buffer is loaded by load_part.
- */
-extern void slurm_free_partition_info_msg ( partition_info_msg_t * part_info_ptr);
-
 #endif
 
diff --git a/src/api/submit.c b/src/api/submit.c
index acaed6e6d1f..df3d8e402c8 100644
--- a/src/api/submit.c
+++ b/src/api/submit.c
@@ -85,7 +85,8 @@ slurm_submit_batch_job (job_desc_msg_t * job_desc_msg,
         switch ( response_msg . msg_type )
         {
                 case RESPONSE_SLURM_RC:
-			slurm_rc_msg = ( return_code_msg_t * ) response_msg . data ;
+			slurm_rc_msg = 
+				( return_code_msg_t * ) response_msg . data ;
 			rc = slurm_rc_msg->return_code;
 			slurm_free_return_code_msg ( slurm_rc_msg );	
 			if (rc) {
@@ -95,7 +96,8 @@ slurm_submit_batch_job (job_desc_msg_t * job_desc_msg,
 			break ;
 		case RESPONSE_SUBMIT_BATCH_JOB:
                         *slurm_alloc_msg = 
-				( submit_response_msg_t * ) response_msg . data ;
+				( submit_response_msg_t * ) 
+				response_msg . data ;
 			return SLURM_PROTOCOL_SUCCESS;
 			break;
                 default:
diff --git a/src/api/update_config.c b/src/api/update_config.c
index 374f244d32c..592ec6c9711 100644
--- a/src/api/update_config.c
+++ b/src/api/update_config.c
@@ -34,7 +34,7 @@
 #include <src/api/slurm.h>
 #include <src/common/slurm_protocol_api.h>
 
-int slurm_update (void * data, slurm_msg_type_t msg_type);
+static int _slurm_update (void * data, slurm_msg_type_t msg_type);
 
 /*
  * slurm_update_job - issue RPC to a job's configuration per request, 
@@ -43,7 +43,7 @@ int slurm_update (void * data, slurm_msg_type_t msg_type);
 int 
 slurm_update_job ( job_desc_msg_t * job_msg ) 
 {
-	return slurm_update ((void *) job_msg, REQUEST_UPDATE_JOB);
+	return _slurm_update ((void *) job_msg, REQUEST_UPDATE_JOB);
 }
 
 /*
@@ -53,7 +53,7 @@ slurm_update_job ( job_desc_msg_t * job_msg )
 int 
 slurm_update_node ( update_node_msg_t * node_msg ) 
 {
-	return slurm_update ((void *) node_msg, REQUEST_UPDATE_NODE);
+	return _slurm_update ((void *) node_msg, REQUEST_UPDATE_NODE);
 }
 
 /*
@@ -63,13 +63,13 @@ slurm_update_node ( update_node_msg_t * node_msg )
 int 
 slurm_update_partition ( update_part_msg_t * part_msg ) 
 {
-	return slurm_update ((void *) part_msg, REQUEST_UPDATE_PARTITION);
+	return _slurm_update ((void *) part_msg, REQUEST_UPDATE_PARTITION);
 }
 
 
-/* slurm_update - issue RPC for all update requests */
+/* _slurm_update - issue RPC for all update requests */
 int 
-slurm_update (void * data, slurm_msg_type_t msg_type)
+_slurm_update (void * data, slurm_msg_type_t msg_type)
 {
 	int msg_size;
 	int rc ;
diff --git a/src/common/slurm_protocol_defs.c b/src/common/slurm_protocol_defs.c
index 18578b1d63f..8f39b78e95e 100644
--- a/src/common/slurm_protocol_defs.c
+++ b/src/common/slurm_protocol_defs.c
@@ -50,11 +50,6 @@ void slurm_free_shutdown_msg(shutdown_msg_t * msg)
 	xfree(msg);
 }
 
-void slurm_free_job_id_msg(job_id_msg_t * msg)
-{
-	xfree(msg);
-}
-
 void slurm_free_job_step_id(job_step_id_t * msg)
 {
 	xfree(msg);
@@ -65,39 +60,6 @@ void slurm_free_return_code_msg(return_code_msg_t * msg)
 	xfree(msg);
 }
 
-void slurm_free_ctl_conf(slurm_ctl_conf_info_msg_t * config_ptr)
-{
-	if (config_ptr) {
-		if (config_ptr->backup_addr)
-			xfree(config_ptr->backup_addr);
-		if (config_ptr->backup_controller)
-			xfree(config_ptr->backup_controller);
-		if (config_ptr->control_addr)
-			xfree(config_ptr->control_addr);
-		if (config_ptr->control_machine)
-			xfree(config_ptr->control_machine);
-		if (config_ptr->epilog)
-			xfree(config_ptr->epilog);
-		if (config_ptr->prioritize)
-			xfree(config_ptr->prioritize);
-		if (config_ptr->prolog)
-			xfree(config_ptr->prolog);
-		if (config_ptr->slurmctld_logfile)
-			xfree(config_ptr->slurmctld_logfile);
-		if (config_ptr->slurmd_logfile)
-			xfree(config_ptr->slurmd_logfile);
-		if (config_ptr->slurmd_spooldir)
-			xfree(config_ptr->slurmd_spooldir);
-		if (config_ptr->slurm_conf)
-			xfree(config_ptr->slurm_conf);
-		if (config_ptr->state_save_location)
-			xfree(config_ptr->state_save_location);
-		if (config_ptr->tmp_fs)
-			xfree(config_ptr->tmp_fs);
-		xfree(config_ptr);
-	}
-}
-
 void slurm_free_job_desc_msg(job_desc_msg_t * msg)
 {
 	int i;
@@ -168,72 +130,6 @@ void slurm_free_job_launch_msg(batch_job_launch_msg_t * msg)
 	}
 }
 
-static void 
-_free_all_partitions(partition_info_msg_t *msg)
-{
-	int i;
-	xassert(msg != NULL);
-	xassert(msg->partition_array != NULL);
-
-	for (i = 0; i < msg->record_count; i++)
-		slurm_free_partition_info_members(&msg->partition_array[i]);
-
-}
-
-void slurm_free_partition_info_msg(partition_info_msg_t * msg)
-{
-	if (msg) {
-		if (msg->partition_array) {
-			_free_all_partitions(msg);
-			xfree(msg->partition_array);
-		}
-		xfree(msg);
-	}
-}
-
-void slurm_free_partition_info(partition_info_t * part)
-{
-	if (part) {
-		slurm_free_partition_info_members(part);
-		xfree(part);
-	}
-}
-
-void slurm_free_partition_info_members(partition_info_t * part)
-{
-	if (part) {
-		if (part->name)
-			xfree(part->name);
-		if (part->allow_groups)
-			xfree(part->allow_groups);
-		if (part->nodes)
-			xfree(part->nodes);
-		if (part->node_inx)
-			xfree(part->node_inx);
-	}
-}
-
-static void _free_all_job_info(job_info_msg_t *msg)
-{
-	int i;
-	xassert(msg != NULL);
-	xassert(msg->job_array != NULL);
-
-	for (i = 0; i < msg->record_count; i++)
-		slurm_free_job_info_members(&msg->job_array[i]);
-}
-
-void slurm_free_job_info_msg(job_info_msg_t * msg)
-{
-	if (msg) {
-		if (msg->job_array) {
-			_free_all_job_info(msg);
-			xfree(msg->job_array);
-		}
-		xfree(msg);
-	}
-}
-
 void slurm_free_job_info(job_info_t * job)
 {
 	if (job) {
@@ -261,132 +157,6 @@ void slurm_free_job_info_members(job_info_t * job)
 	}
 }
 
-void slurm_free_job_step_info_members(job_step_info_t * msg)
-{
-	if (msg != NULL) {
-		if (msg->partition != NULL)
-			xfree(msg->partition);
-		if (msg->nodes != NULL)
-			xfree(msg->nodes);
-	}
-}
-
-void slurm_free_job_step_info(job_step_info_t * msg)
-{
-	if (msg != NULL) {
-		slurm_free_job_step_info_members(msg);
-		xfree(msg);
-	}
-}
-
-
-static void _free_all_step_info(job_step_info_response_msg_t *msg)
-{
-	int i;
-	xassert (msg != NULL);
-	xassert (msg->job_steps != NULL);
-
-	for (i = 0; i < msg->job_step_count; i++)
-		slurm_free_job_step_info_members(&msg->job_steps[i]);
-}
-
-void slurm_free_job_step_info_response_msg(job_step_info_response_msg_t *
-					   msg)
-{
-	if (msg != NULL) {
-		if (msg->job_steps != NULL) {
-			_free_all_step_info(msg);
-			xfree(msg->job_steps);
-		}
-		xfree(msg);
-	}
-}
-
-static void _free_all_node_info(node_info_msg_t *msg)
-{
-	int i;
-	xassert(msg != NULL);
-	xassert(msg->node_array != NULL);
-	
-	for (i = 0; i < msg->record_count; i++) 
-		slurm_free_node_info_members(&msg->node_array[i]);
-}
-
-void slurm_free_node_info_msg(node_info_msg_t * msg)
-{
-	if (msg) {
-		if (msg->node_array) {
-			_free_all_node_info(msg);
-			xfree(msg->node_array);
-		}
-		xfree(msg);
-	}
-}
-
-void slurm_free_node_info(node_info_t * node)
-{
-	if (node) {
-		slurm_free_node_info_members(node);
-		xfree(node);
-	}
-}
-
-void slurm_free_node_info_members(node_info_t * node)
-{
-	if (node) {
-		if (node->name)
-			xfree(node->name);
-		if (node->features)
-			xfree(node->features);
-		if (node->partition)
-			xfree(node->partition);
-	}
-}
-
-void
-slurm_free_resource_allocation_response_msg
-(resource_allocation_response_msg_t * msg)
-{
-	if (msg) {
-		if (msg->node_list)
-			xfree(msg->node_list);
-		if (msg->cpus_per_node)
-			xfree(msg->cpus_per_node);
-		if (msg->cpu_count_reps)
-			xfree(msg->cpu_count_reps);
-		if (msg->node_addr)
-			xfree(msg->node_addr);
-		xfree(msg);
-	}
-}
-
-void
-slurm_free_resource_allocation_and_run_response_msg
-(resource_allocation_and_run_response_msg_t * msg)
-{
-	if (msg) {
-		if (msg->node_list)
-			xfree(msg->node_list);
-		if (msg->cpus_per_node)
-			xfree(msg->cpus_per_node);
-		if (msg->cpu_count_reps)
-			xfree(msg->cpu_count_reps);
-		if (msg->credentials)
-			xfree(msg->credentials);
-		if (msg->node_addr)
-			xfree(msg->node_addr);
-#		ifdef HAVE_LIBELAN3
-		qsw_free_jobinfo(msg->qsw_job);
-#		endif
-		xfree(msg);
-	}
-}
-
-void slurm_free_submit_response_response_msg(submit_response_msg_t * msg)
-{
-	if (msg)
-		xfree(msg);
-}
 
 void
 slurm_free_node_registration_status_msg
@@ -436,21 +206,6 @@ void slurm_free_job_step_create_request_msg(job_step_create_request_msg_t *
 	}
 }
 
-void slurm_free_job_step_create_response_msg(job_step_create_response_msg_t
-					     * msg)
-{
-	if (msg) {
-		if (msg->credentials)
-			xfree(msg->credentials);
-
-#		ifdef HAVE_LIBELAN3
-		qsw_free_jobinfo(msg->qsw_job);
-#		endif
-
-		xfree(msg);
-	}
-
-}
 
 void slurm_free_launch_tasks_response_msg(launch_tasks_response_msg_t *
 					  msg)
diff --git a/src/common/slurm_protocol_defs.h b/src/common/slurm_protocol_defs.h
index ac5a47258b9..51ab9676535 100644
--- a/src/common/slurm_protocol_defs.h
+++ b/src/common/slurm_protocol_defs.h
@@ -586,8 +586,6 @@ typedef struct slurm_node_registration_status_msg {
 typedef struct slurm_ctl_conf slurm_ctl_conf_info_msg_t;
 
 
-/* the following typedefs follow kevin's communication message naming comvention */
-
 /* free message functions */
 void inline slurm_free_last_update_msg(last_update_msg_t * msg);
 void inline slurm_free_return_code_msg(return_code_msg_t * msg);
@@ -597,49 +595,23 @@ void inline slurm_free_job_step_id(job_step_id_t * msg);
 #define slurm_free_job_step_info_request_msg(msg) slurm_free_job_step_id(msg)
 #define slurm_free_job_info_request_msg(msg) slurm_free_job_step_id(msg)
 
-void inline slurm_free_ctl_conf(slurm_ctl_conf_info_msg_t * build_ptr);
 void inline slurm_free_shutdown_msg (shutdown_msg_t * msg);
 
 void inline slurm_free_job_desc_msg(job_desc_msg_t * msg);
-void inline
-slurm_free_resource_allocation_response_msg
-(resource_allocation_response_msg_t * msg);
-void inline
-slurm_free_resource_allocation_and_run_response_msg
-(resource_allocation_and_run_response_msg_t * msg);
-void inline slurm_free_submit_response_response_msg(submit_response_msg_t *
-						    msg);
 
 void inline
 slurm_free_node_registration_status_msg (slurm_node_registration_status_msg_t * msg);
 
-void inline slurm_free_job_info_msg(job_info_msg_t * msg);
 void inline slurm_free_job_info(job_info_t * job);
 void inline slurm_free_job_info_members(job_info_t * job);
 
-void inline slurm_free_job_step_info(job_step_info_t * msg);
-void inline slurm_free_job_step_info_memebers(job_step_info_t * msg);
-void inline
-slurm_free_job_step_info_response_msg(job_step_info_response_msg_t * msg);
-
 void inline slurm_free_job_launch_msg(batch_job_launch_msg_t * msg);
 
-void inline slurm_free_partition_info_msg(partition_info_msg_t * msg);
-void inline slurm_free_partition_info(partition_info_t * part);
-void inline slurm_free_partition_info_members(partition_info_t * part);
-
-void inline slurm_free_node_info_msg(node_info_msg_t * msg);
-void inline slurm_free_node_info(node_info_t * node);
-void inline slurm_free_node_info_members(node_info_t * node);
-
 void inline slurm_free_update_node_msg(update_node_msg_t * msg);
 void inline slurm_free_update_part_msg(update_part_msg_t * msg);
 void inline
 slurm_free_job_step_create_request_msg(job_step_create_request_msg_t *
 				       msg);
-void inline
-slurm_free_job_step_create_response_msg(job_step_create_response_msg_t *
-					msg);
 void inline slurm_free_launch_tasks_request_msg(launch_tasks_request_msg_t
 						* msg);
 void inline
-- 
GitLab