slurm_protocol_pack.c

void pack_return_code ( return_code_msg_t * msg , void ** buffer , uint32_t * length )
{
	pack32 ( msg -> return_code , buffer , length ) ;
}

int unpack_return_code ( return_code_msg_t ** msg , void ** buffer , uint32_t * length )
{
        return_code_msg_t * return_code_msg ;

        return_code_msg = xmalloc ( sizeof ( return_code_msg_t ) ) ;
        if ( return_code_msg == NULL)
        {
                *msg = NULL ;
                return ENOMEM ;
        }

	unpack32 ( & return_code_msg -> return_code , buffer , length ) ;
	*msg = return_code_msg ;
	return 0 ;
}

void pack_reattach_tasks_streams_msg ( reattach_tasks_streams_msg_t * msg , void ** buffer , uint32_t * length )
{
	pack32 ( msg -> job_id , buffer , length ) ;
	pack32 ( msg -> job_step_id , buffer , length ) ;
	pack32 ( msg -> uid , buffer , length ) ;
	pack_job_credential ( msg -> credentials , buffer , length ) ;
	pack32 ( msg -> tasks_to_reattach , buffer , length ) ;
	pack_slurm_addr_array ( msg -> streams , ( uint16_t ) msg -> tasks_to_reattach, buffer , length ) ;
	pack32_array ( msg -> global_task_ids , ( uint16_t ) msg -> tasks_to_reattach , buffer , length ) ;
}

int unpack_reattach_tasks_streams_msg ( reattach_tasks_streams_msg_t ** msg_ptr , void ** buffer , uint32_t * length )
{
	uint16_t uint16_tmp;
	reattach_tasks_streams_msg_t * msg ;

	msg = xmalloc ( sizeof ( job_desc_msg_t ) ) ;
	if (msg == NULL) 
	{
		*msg_ptr = NULL ;
		return ENOMEM ;
	}

	unpack32 ( & msg -> job_id , buffer , length ) ;
	unpack32 ( & msg -> job_step_id , buffer , length ) ;
	unpack32 ( & msg -> uid , buffer , length ) ;
	unpack_job_credential( & msg -> credentials ,  buffer , length ) ;
	unpack32 ( & msg -> tasks_to_reattach , buffer , length ) ;
	unpack_slurm_addr_array ( & msg -> streams , & uint16_tmp , buffer , length ) ;
	unpack32_array ( & msg -> global_task_ids , & uint16_tmp , buffer , length ) ;
	*msg_ptr = msg ;
	return 0 ;
}

void pack_launch_tasks_msg ( launch_tasks_msg_t * msg , void ** buffer , uint32_t * length )
{
	pack32 ( msg -> job_id , buffer , length ) ;
	pack32 ( msg -> job_step_id , buffer , length ) ;
	pack32 ( msg -> uid , buffer , length ) ;
	pack_job_credential ( msg -> credentials , buffer , length ) ;
	pack32 ( msg -> tasks_to_launch , buffer , length ) ;
	packstring_array ( msg -> env , msg -> envc , buffer , length ) ;
	packstr ( msg -> cwd , buffer , length ) ;
	packstr ( msg -> cmd_line , buffer , length ) ;
	slurm_pack_slurm_addr ( & msg -> response_addr , buffer , length ) ;
	pack_slurm_addr_array ( msg -> streams , ( uint16_t ) msg -> tasks_to_launch , buffer , length ) ;
	pack32_array ( msg -> global_task_ids , ( uint16_t ) msg -> tasks_to_launch , buffer , length ) ;
}

int unpack_launch_tasks_msg ( launch_tasks_msg_t ** msg_ptr , void ** buffer , uint32_t * length )
{
	uint16_t uint16_tmp;
	launch_tasks_msg_t * msg ;

	msg = xmalloc ( sizeof ( job_desc_msg_t ) ) ;
	if (msg == NULL) 
	{
		*msg_ptr = NULL ;
		return ENOMEM ;
	}

	unpack32 ( & msg -> job_id , buffer , length ) ;
	unpack32 ( & msg -> job_step_id , buffer , length ) ;
	unpack32 ( & msg -> uid , buffer , length ) ;
	unpack_job_credential( & msg -> credentials ,  buffer , length ) ;
	unpack32 ( & msg -> tasks_to_launch , buffer , length ) ;
	unpackstring_array ( & msg -> env , & msg -> envc , buffer , length ) ;
	unpackstr_xmalloc ( & msg -> cwd , & uint16_tmp , buffer , length ) ;
	unpackstr_xmalloc ( & msg -> cmd_line , & uint16_tmp , buffer , length ) ;
	slurm_unpack_slurm_addr_no_alloc ( & msg -> response_addr , buffer , length ) ;
	unpack_slurm_addr_array ( & msg -> streams , & uint16_tmp , buffer , length ) ;
	unpack32_array ( & msg -> global_task_ids , & uint16_tmp , buffer , length ) ;
	*msg_ptr = msg ;
	return 0 ;
}

void pack_cancel_tasks_msg ( kill_tasks_msg_t * msg , void ** buffer , uint32_t * length )
{
	pack32 ( msg -> job_id , buffer , length ) ;
	pack32 ( msg -> job_step_id , buffer , length ) ;
	pack32 ( msg -> signal , buffer , length ) ;
}

int unpack_cancel_tasks_msg ( kill_tasks_msg_t ** msg_ptr , void ** buffer , uint32_t * length )
{
	kill_tasks_msg_t * msg ;

	msg = xmalloc ( sizeof ( job_desc_msg_t ) ) ;
	if ( msg == NULL) 
	{
		*msg_ptr = NULL ;
		return ENOMEM ;
	}

	unpack32 ( & msg -> job_id , buffer , length ) ;
	unpack32 ( & msg -> job_step_id , buffer , length ) ;
	unpack32 ( & msg -> signal , buffer , length ) ;
	*msg_ptr = msg ;
	return 0 ;
}

void pack_cancel_job_step_msg ( job_step_id_msg_t * msg , void ** buffer , uint32_t * length )
{
	pack32 ( msg -> job_id , buffer , length ) ;
	pack32 ( msg -> job_step_id , buffer , length ) ;
}

int unpack_cancel_job_step_msg ( job_step_id_msg_t ** msg_ptr , void ** buffer , uint32_t * length )
{
	job_step_id_msg_t * msg ;

	msg = xmalloc ( sizeof ( job_step_id_msg_t ) ) ;
	if ( msg == NULL) 
	{
		*msg_ptr = NULL ;
		return ENOMEM ;
	}

	unpack32 ( & msg -> job_id , buffer , length ) ;
	unpack32 ( & msg -> job_step_id , buffer , length ) ;
	*msg_ptr = msg ;
	return 0 ;
}

/* template 
void pack_ ( * msg , void ** buffer , uint32_t * length )
{
	pack16 ( msg -> , buffer , length ) ;
	pack32 ( msg -> , buffer , length ) ;
	packstr ( msg -> , buffer , length ) ;
}

void unpack_ ( ** msg_ptr , void ** buffer , uint32_t * length )
{
	uint16_t uint16_tmp;
	* msg ;

	msg = xmalloc ( sizeof ( job_desc_msg_t ) ) ;
	if (msg == NULL) 
	{
		*msg_ptr = NULL ;
		return ;
	}

	unpack16 ( & msg -> , buffer , length ) ;
	unpack32 ( & msg -> , buffer , length ) ;
	unpackstr_xmalloc ( & msg -> , & uint16_tmp , buffer , length ) ;
	*msg_ptr = msg ;
}
*/

void pack_slurm_addr_array ( slurm_addr * slurm_address , uint16_t size_val, void ** buffer , int * length )
{
	int i=0;
	uint16_t nl = htons(size_val);
	_pack16( nl, buffer, length);

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

void unpack_slurm_addr_array ( slurm_addr ** slurm_address , uint16_t * size_val , void ** buffer , int * length )
{
	int i=0;
	_unpack16( size_val, buffer , length );
	slurm_address = xmalloc( (*size_val) * sizeof( slurm_addr ) );

	for ( i=0; i < *size_val; i++ ) 
	{
		slurm_unpack_slurm_addr_no_alloc ( (*slurm_address) + i , buffer , length );
	}
}