slurm_protocol_pack.c

	pack16( nl, buffer );

	for ( i=0; i < size_val; i++ ) 
	{
		slurm_pack_slurm_addr ( slurm_address + i , buffer ) ;
	}
	
}

int 
unpack_slurm_addr_array ( slurm_addr ** slurm_address , 
                          uint16_t * size_val , Buf buffer )
{
	int i=0;
	uint16_t nl ;

	*slurm_address = NULL;
	safe_unpack16( & nl , buffer );
	*size_val = ntohs ( nl ) ;
	*slurm_address = xmalloc( (*size_val) * sizeof( slurm_addr ) );

	for ( i=0; i < *size_val; i++ ) 
	{
		if (slurm_unpack_slurm_addr_no_alloc ( 
					(*slurm_address) + i , buffer ))
			goto unpack_error;

	}
	return SLURM_SUCCESS;

    unpack_error:
	if (*slurm_address)
		xfree (*slurm_address);
	*slurm_address = NULL;
	return SLURM_ERROR;
}

void 
pack_batch_job_launch ( batch_job_launch_msg_t* msg , Buf buffer )
{
	assert ( msg != NULL );

	pack32 ( msg -> job_id, buffer ) ;
	pack32 ( msg -> uid, buffer ) ;

	packstr ( msg -> nodes, buffer ) ;
	packstr ( msg -> script, buffer ) ;
	packstr ( msg -> work_dir, buffer ) ;

	packstr ( msg -> err, buffer ) ;
	packstr ( msg -> in, buffer ) ;
	packstr ( msg -> out, buffer ) ;

	pack16 ( msg -> argc, buffer ) ;
	packstr_array (msg -> argv, msg -> argc, buffer);

	pack16 ( msg -> envc, buffer ) ;
	packstr_array (msg -> environment, msg -> envc, buffer);
}

int 
unpack_batch_job_launch( batch_job_launch_msg_t** msg , Buf buffer )
{
	uint16_t uint16_tmp;
	batch_job_launch_msg_t *launch_msg_ptr ;

	assert ( msg != NULL );
	launch_msg_ptr = xmalloc ( sizeof (batch_job_launch_msg_t) ) ;
	*msg = launch_msg_ptr ;

	safe_unpack32 ( & launch_msg_ptr -> job_id, buffer ) ;
	safe_unpack32 ( & launch_msg_ptr -> uid, buffer ) ;

	safe_unpackstr_xmalloc ( & launch_msg_ptr -> nodes, 
	                         & uint16_tmp , buffer ) ;
	safe_unpackstr_xmalloc ( & launch_msg_ptr -> script, 
	                         & uint16_tmp , buffer ) ;
	safe_unpackstr_xmalloc ( & launch_msg_ptr -> work_dir, 
	                         & uint16_tmp , buffer ) ;

	safe_unpackstr_xmalloc ( & launch_msg_ptr -> err, 
	                         & uint16_tmp , buffer ) ;
	safe_unpackstr_xmalloc ( & launch_msg_ptr -> in, 
	                         & uint16_tmp , buffer ) ;
	safe_unpackstr_xmalloc ( & launch_msg_ptr -> out, 
	                         & uint16_tmp , buffer ) ;

	safe_unpack16 ( & launch_msg_ptr -> argc, buffer ) ;
	safe_unpackstr_array (& launch_msg_ptr -> argv, 
	                      &launch_msg_ptr -> argc, buffer);

	safe_unpack16 ( & launch_msg_ptr -> envc, buffer ) ;
	safe_unpackstr_array (& launch_msg_ptr -> environment, 	
	                      &launch_msg_ptr -> envc, buffer);

	return SLURM_SUCCESS;

    unpack_error:
	if (launch_msg_ptr -> nodes)
		xfree (launch_msg_ptr -> nodes);
	if (launch_msg_ptr -> script)
		xfree (launch_msg_ptr -> script);
	if (launch_msg_ptr -> work_dir)
		xfree (launch_msg_ptr -> work_dir);
	if (launch_msg_ptr -> err)
		xfree (launch_msg_ptr -> err);
	if (launch_msg_ptr -> in)
		xfree (launch_msg_ptr -> in);
	if (launch_msg_ptr -> out)
		xfree (launch_msg_ptr -> out);
	if (launch_msg_ptr -> argv)
		xfree (launch_msg_ptr -> argv);
	if (launch_msg_ptr -> environment)
		xfree (launch_msg_ptr -> environment);
	xfree (launch_msg_ptr);
	*msg = NULL;
	return SLURM_ERROR;
}

/* template 
void pack_ ( * msg , Buf buffer )
{
	assert ( msg != NULL );

	pack16 ( msg -> , buffer ) ;
	pack32 ( msg -> , buffer ) ;
	packstr ( msg -> , buffer ) ;
}

int unpack_ ( ** msg_ptr , Buf buffer )
{
	uint16_t uint16_tmp;
	* msg ;

	assert ( msg_ptr != NULL );

	msg = xmalloc ( sizeof ( ) ) ;
	*msg_ptr = msg;

	safe_unpack16 ( & msg -> , buffer ) ;
	safe_unpack32 ( & msg -> , buffer ) ;
	safe_unpackstr_xmalloc ( & msg -> x, & uint16_tmp , buffer ) ;
	return SLURM_SUCCESS;

    unpack_error:
	if (msg -> x)
		xfree (msg -> x);
	xfree (msg);
	*msg_ptr = NULL;
	return SLURM_ERROR;
}
*/