/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */

/*  

 *  (C) 2001 by Argonne National Laboratory.

 *      See COPYRIGHT in top-level directory.

 */

/*********************** PMI implementation ********************************/

/*

 * This file implements the client-side of the PMI interface.

 *

 * Note that the PMI client code must not print error messages (except 

 * when an abort is required) because MPI error handling is based on

 * reporting error codes to which messages are attached.  

 *

 * In v2, we should require a PMI client interface to use MPI error codes

 * to provide better integration with MPICH.  

 */

/***************************************************************************/

#include "mpichconf.h"

#define PMI_VERSION    1

#define PMI_SUBVERSION 1

#include <stdio.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#ifdef HAVE_STRINGS_H

#include <strings.h>

#endif

#ifdef USE_PMI_PORT

#ifndef MAXHOSTNAME

#define MAXHOSTNAME 256

#endif

#endif

/* This should be moved to pmiu for shutdown */

#if defined(HAVE_SYS_SOCKET_H)

#include <sys/socket.h>

#endif

#include "mpl.h"            /* Get ATTRIBUTE, some base functions */

/* mpimem includes the definitions for MPL_snprintf, MPIU_Malloc, and 

   MPIU_Free */

#include "mpimem.h"

/* Temporary debug definitions */

/* #define DBG_PRINTF(args) printf args ; fflush(stdout) */

#define DBG_PRINTF(args)

#include "pmi.h"

#include "simple_pmiutil.h"

#include "mpi.h"		/* to get MPI_MAX_PORT_NAME */

/* 

   These are global variable used *ONLY* in this file, and are hence

   declared static.

 */

static int PMI_fd = -1;

static int PMI_size = 1;

static int PMI_rank = 0;

/* Set PMI_initialized to 1 for singleton init but no process manager

   to help.  Initialized to 2 for normal initialization.  Initialized

   to values higher than 2 when singleton_init by a process manager.

   All values higher than 1 invlove a PM in some way.

*/

typedef enum { PMI_UNINITIALIZED = 0, 

               SINGLETON_INIT_BUT_NO_PM = 1,

	       NORMAL_INIT_WITH_PM,

	       SINGLETON_INIT_WITH_PM } PMIState;

static PMIState PMI_initialized = PMI_UNINITIALIZED;

/* ALL GLOBAL VARIABLES MUST BE INITIALIZED TO AVOID POLLUTING THE 

   LIBRARY WITH COMMON SYMBOLS */

static int PMI_kvsname_max = 0;

static int PMI_keylen_max = 0;

static int PMI_vallen_max = 0;

static int PMI_debug = 0;

static int PMI_debug_init = 0;    /* Set this to true to debug the init

				     handshakes */

static int PMI_spawned = 0;

/* Function prototypes for internal routines */

static int PMII_getmaxes( int *kvsname_max, int *keylen_max, int *vallen_max );

static int PMII_Set_from_port( int, int );

static int PMII_Connect_to_pm( char *, int );

static int GetResponse( const char [], const char [], int );

static int getPMIFD( int * );

#ifdef USE_PMI_PORT

static int PMII_singinit(void);

static int PMI_totalview = 0;

#endif

static int PMIi_InitIfSingleton(void);

static int accept_one_connection(int);

static int cached_singinit_inuse = 0;

static char cached_singinit_key[PMIU_MAXLINE];

static char cached_singinit_val[PMIU_MAXLINE];

static char singinit_kvsname[256];

/******************************** Group functions *************************/

int PMI_Init( int *spawned )

{

    char *p;

    int notset = 1;

    int rc;

    PMI_initialized = PMI_UNINITIALIZED;

    /* FIXME: Why is setvbuf commented out? */

    /* FIXME: What if the output should be fully buffered (directed to file)?

       unbuffered (user explicitly set?) */

    /* setvbuf(stdout,0,_IONBF,0); */

    setbuf(stdout,NULL);

    /* PMIU_printf( 1, "PMI_INIT\n" ); */

    /* Get the value of PMI_DEBUG from the environment if possible, since

       we may have set it to help debug the setup process */

    p = getenv( "PMI_DEBUG" );

    if (p) PMI_debug = atoi( p );

    /* Get the fd for PMI commands; if none, we're a singleton */

    rc = getPMIFD(&notset);

    if (rc) {

	return rc;

    }

    if ( PMI_fd == -1 ) {

	/* Singleton init: Process not started with mpiexec, 

	   so set size to 1, rank to 0 */

	PMI_size = 1;

	PMI_rank = 0;

	*spawned = 0;

	PMI_initialized = SINGLETON_INIT_BUT_NO_PM;

	/* 256 is picked as the minimum allowed length by the PMI servers */

	PMI_kvsname_max = 256;

	PMI_keylen_max  = 256;

	PMI_vallen_max  = 256;

	return( 0 );

    }

    /* If size, rank, and debug are not set from a communication port,

       use the environment */

    if (notset) {

	if ( ( p = getenv( "PMI_SIZE" ) ) )

	    PMI_size = atoi( p );

	else 

	    PMI_size = 1;

	if ( ( p = getenv( "PMI_RANK" ) ) ) {

	    PMI_rank = atoi( p );

	    /* Let the util routine know the rank of this process for 

	       any messages (usually debugging or error) */

	    PMIU_Set_rank( PMI_rank );

	}

	else 

	    PMI_rank = 0;

	if ( ( p = getenv( "PMI_DEBUG" ) ) )

	    PMI_debug = atoi( p );

	else 

	    PMI_debug = 0;

	/* Leave unchanged otherwise, which indicates that no value

	   was set */

    }

/* FIXME: Why does this depend on their being a port??? */

/* FIXME: What is this for? */

#ifdef USE_PMI_PORT

    if ( ( p = getenv( "PMI_TOTALVIEW" ) ) )

	PMI_totalview = atoi( p );

    if ( PMI_totalview ) {

	char buf[PMIU_MAXLINE], cmd[PMIU_MAXLINE];

	/* FIXME: This should use a cmd/response rather than a expecting the

	   server to set a value in this and only this case */

	/* FIXME: And it most ceratainly should not happen *before* the

	   initialization handshake */

	PMIU_readline( PMI_fd, buf, PMIU_MAXLINE );

	PMIU_parse_keyvals( buf );

	PMIU_getval( "cmd", cmd, PMIU_MAXLINE );

	if ( strncmp( cmd, "tv_ready", PMIU_MAXLINE ) != 0 ) {

	    PMIU_printf( 1, "expecting cmd=tv_ready, got %s\n", buf );

	    return( PMI_FAIL );

	}

    }

#endif

    PMII_getmaxes( &PMI_kvsname_max, &PMI_keylen_max, &PMI_vallen_max );

    /* FIXME: This is something that the PM should tell the process,

       rather than deliver it through the environment */

    if ( ( p = getenv( "PMI_SPAWNED" ) ) )

	PMI_spawned = atoi( p );

    else

	PMI_spawned = 0;

    if (PMI_spawned)

	*spawned = 1;

    else

	*spawned = 0;

    if ( ! PMI_initialized )

	PMI_initialized = NORMAL_INIT_WITH_PM;

    return( 0 );

}

int PMI_Initialized( int *initialized )

{

    /* Turn this into a logical value (1 or 0) .  This allows us

       to use PMI_initialized to distinguish between initialized with

       an PMI service (e.g., via mpiexec) and the singleton init, 

       which has no PMI service */

    *initialized = (PMI_initialized != 0);

    return PMI_SUCCESS;

}

int PMI_Get_size( int *size )

{

    if ( PMI_initialized )

	*size = PMI_size;

    else

	*size = 1;

    return( 0 );

}

int PMI_Get_rank( int *rank )

{

    if ( PMI_initialized )

	*rank = PMI_rank;

    else

	*rank = 0;

    return( 0 );

}

/* 

 * Get_universe_size is one of the routines that needs to communicate

 * with the process manager.  If we started as a singleton init, then

 * we first need to connect to the process manager and acquire the 

 * needed information.

 */

int PMI_Get_universe_size( int *size)

{

    int  err;

    char size_c[PMIU_MAXLINE];

    /* Connect to the PM if we haven't already */

    if (PMIi_InitIfSingleton() != 0) return -1;

    if ( PMI_initialized > SINGLETON_INIT_BUT_NO_PM)  {

	err = GetResponse( "cmd=get_universe_size\n", "universe_size", 0 );

	if (err == PMI_SUCCESS) {

	    PMIU_getval( "size", size_c, PMIU_MAXLINE );

	    *size = atoi(size_c);

	    return( PMI_SUCCESS );

	}

	else return err;

    }

    else

	*size = 1;

    return( PMI_SUCCESS );

}

int PMI_Get_appnum( int *appnum )

{

    int  err;

    char appnum_c[PMIU_MAXLINE];

    if ( PMI_initialized > SINGLETON_INIT_BUT_NO_PM) {

	err = GetResponse( "cmd=get_appnum\n", "appnum", 0 );

	if (err == PMI_SUCCESS) {

	    PMIU_getval( "appnum", appnum_c, PMIU_MAXLINE );

	    *appnum = atoi(appnum_c);

	    return( PMI_SUCCESS );

	}

	else return err;

    }

    else

	*appnum = -1;

    return( PMI_SUCCESS );

}

int PMI_Barrier( void )

{

    int err = PMI_SUCCESS;

    if ( PMI_initialized > SINGLETON_INIT_BUT_NO_PM) {

	err = GetResponse( "cmd=barrier_in\n", "barrier_out", 0 );

    }

    return err;

}

/* Inform the process manager that we're in finalize */

int PMI_Finalize( void )

{

    int err = PMI_SUCCESS;

    if ( PMI_initialized > SINGLETON_INIT_BUT_NO_PM) {

	err = GetResponse( "cmd=finalize\n", "finalize_ack", 0 );

	shutdown( PMI_fd, SHUT_RDWR );

	close( PMI_fd );

    }

    return err;

}

int PMI_Abort(int exit_code, const char error_msg[])

{

    char buf[PMIU_MAXLINE];

    /* include exit_code in the abort command */

    MPL_snprintf( buf, PMIU_MAXLINE, "cmd=abort exitcode=%d\n", exit_code);

    PMIU_printf(PMI_debug, "aborting job:\n%s\n", error_msg);

    GetResponse( buf, "", 0 );

    /* the above command should not return */

    return -1;

}

/************************************* Keymap functions **********************/

/*FIXME: need to return an error if the value of the kvs name returned is 

  truncated because it is larger than length */

/* FIXME: My name should be cached rather than re-acquired, as it is

   unchanging (after singleton init) */

int PMI_KVS_Get_my_name( char kvsname[], int length )

{

    int err;

    if (PMI_initialized == SINGLETON_INIT_BUT_NO_PM) {

	/* Return a dummy name */

	/* FIXME: We need to support a distinct kvsname for each 

	   process group */

	MPL_snprintf( kvsname, length, "singinit_kvs_%d_0", (int)getpid() );

	return 0;

    }

    err = GetResponse( "cmd=get_my_kvsname\n", "my_kvsname", 0 );

    if (err == PMI_SUCCESS) {

	PMIU_getval( "kvsname", kvsname, length );

    }

    return err;

}

int PMI_KVS_Get_name_length_max( int *maxlen )

{

    if (maxlen == NULL)

	return PMI_ERR_INVALID_ARG;

    *maxlen = PMI_kvsname_max;

    return PMI_SUCCESS;

}

int PMI_KVS_Get_key_length_max( int *maxlen )

{

    if (maxlen == NULL)

	return PMI_ERR_INVALID_ARG;

    *maxlen = PMI_keylen_max;

    return PMI_SUCCESS;

}

int PMI_KVS_Get_value_length_max( int *maxlen )

{

    if (maxlen == NULL)

	return PMI_ERR_INVALID_ARG;

    *maxlen = PMI_vallen_max;

    return PMI_SUCCESS;

}

int PMI_KVS_Put( const char kvsname[], const char key[], const char value[] )

{

    char buf[PMIU_MAXLINE];

    int  err = PMI_SUCCESS;

    int  rc;

    /* This is a special hack to support singleton initialization */

    if (PMI_initialized == SINGLETON_INIT_BUT_NO_PM) {

        if (cached_singinit_inuse)

            return PMI_FAIL;

	rc = MPIU_Strncpy(cached_singinit_key,key,PMI_keylen_max);

	if (rc != 0) return PMI_FAIL;

	rc = MPIU_Strncpy(cached_singinit_val,value,PMI_vallen_max);

	if (rc != 0) return PMI_FAIL;

        cached_singinit_inuse = 1;

	return PMI_SUCCESS;

    }

    rc = MPL_snprintf( buf, PMIU_MAXLINE, 

			"cmd=put kvsname=%s key=%s value=%s\n",

			kvsname, key, value);

    if (rc < 0) return PMI_FAIL;

    err = GetResponse( buf, "put_result", 1 );

    return err;

}

int PMI_KVS_Commit( const char kvsname[] ATTRIBUTE((unused)))

{

    /* no-op in this implementation */

    return( 0 );

}

/*FIXME: need to return an error if the value returned is truncated

  because it is larger than length */

int PMI_KVS_Get( const char kvsname[], const char key[], char value[], 

		 int length)

{

    char buf[PMIU_MAXLINE];

    int err = PMI_SUCCESS;

    int  rc;

    /* Connect to the PM if we haven't already.  This is needed in case

       we're doing an MPI_Comm_join or MPI_Comm_connect/accept from

       the singleton init case.  This test is here because, in the way in 

       which MPICH uses PMI, this is where the test needs to be. */

    if (PMIi_InitIfSingleton() != 0) return -1;

    rc = MPL_snprintf( buf, PMIU_MAXLINE, "cmd=get kvsname=%s key=%s\n", 

			kvsname, key );

    if (rc < 0) return PMI_FAIL;

    err = GetResponse( buf, "get_result", 0 );

    if (err == PMI_SUCCESS) {

	PMIU_getval( "rc", buf, PMIU_MAXLINE );

	rc = atoi( buf );

	if ( rc == 0 ) {

	    PMIU_getval( "value", value, length );

	    return( 0 );

	}

	else {

	    return( -1 );

	}

    }

    return err;

}

/*************************** Name Publishing functions **********************/

int PMI_Publish_name( const char service_name[], const char port[] )

{

    char buf[PMIU_MAXLINE], cmd[PMIU_MAXLINE];

    int err;

    if ( PMI_initialized > SINGLETON_INIT_BUT_NO_PM) {

        MPL_snprintf( cmd, PMIU_MAXLINE, 

		       "cmd=publish_name service=%s port=%s\n",

		       service_name, port );

	err = GetResponse( cmd, "publish_result", 0 );

	if (err == PMI_SUCCESS) {

	    PMIU_getval( "rc", buf, PMIU_MAXLINE );

	    if ( strcmp(buf,"0") != 0 ) {

                PMIU_getval( "msg", buf, PMIU_MAXLINE );

                PMIU_printf( PMI_debug, "publish failed; reason = %s\n", buf );

	        return( PMI_FAIL );

	    }

	}

    }

    else

    {

	PMIU_printf( 1, "PMI_Publish_name called before init\n" );

	return( PMI_FAIL );

    }

    return( PMI_SUCCESS );

}

int PMI_Unpublish_name( const char service_name[] )

{

    char buf[PMIU_MAXLINE], cmd[PMIU_MAXLINE];

    int err = PMI_SUCCESS;

    if ( PMI_initialized > SINGLETON_INIT_BUT_NO_PM) {

        MPL_snprintf( cmd, PMIU_MAXLINE, "cmd=unpublish_name service=%s\n", 

		       service_name );

	err = GetResponse( cmd, "unpublish_result", 0 );

	if (err == PMI_SUCCESS) {

	    PMIU_getval( "rc", buf, PMIU_MAXLINE );

	    if ( strcmp(buf,"0") != 0 ) {

                PMIU_getval( "msg", buf, PMIU_MAXLINE );

                PMIU_printf( PMI_debug, "unpublish failed; reason = %s\n", buf );

                return( PMI_FAIL );

	    }

	}

    }

    else

    {

	PMIU_printf( 1, "PMI_Unpublish_name called before init\n" );

	return( PMI_FAIL );

    }

    return( PMI_SUCCESS );

}

int PMI_Lookup_name( const char service_name[], char port[] )

{

    char buf[PMIU_MAXLINE], cmd[PMIU_MAXLINE];

    int err;

    if ( PMI_initialized > SINGLETON_INIT_BUT_NO_PM) {

        MPL_snprintf( cmd, PMIU_MAXLINE, "cmd=lookup_name service=%s\n", 

		       service_name );

	err = GetResponse( cmd, "lookup_result", 0 );

	if (err == PMI_SUCCESS) {

	    PMIU_getval( "rc", buf, PMIU_MAXLINE );

	    if ( strcmp(buf,"0") != 0 ) {

                PMIU_getval( "msg", buf, PMIU_MAXLINE );

                PMIU_printf( PMI_debug, "lookup failed; reason = %s\n", buf );

	        return( PMI_FAIL );

	    }

	    PMIU_getval( "port", port, MPI_MAX_PORT_NAME );

	}

    }

    else

    {

	PMIU_printf( 1, "PMI_Lookup_name called before init\n" );

	return( PMI_FAIL );

    }

    return( PMI_SUCCESS );

}

/************************** Process Creation functions **********************/

int PMI_Spawn_multiple(int count,

                       const char * cmds[],

                       const char ** argvs[],

                       const int maxprocs[],

                       const int info_keyval_sizes[],

                       const PMI_keyval_t * info_keyval_vectors[],

                       int preput_keyval_size,

                       const PMI_keyval_t preput_keyval_vector[],

                       int errors[])

{

    int  i,rc,argcnt,spawncnt,total_num_processes,num_errcodes_found;

    char buf[PMIU_MAXLINE], tempbuf[PMIU_MAXLINE], cmd[PMIU_MAXLINE];

    char *lead, *lag;

    /* Connect to the PM if we haven't already */

    if (PMIi_InitIfSingleton() != 0) return -1;

    total_num_processes = 0;

    for (spawncnt=0; spawncnt < count; spawncnt++)

    {

        total_num_processes += maxprocs[spawncnt];

        rc = MPL_snprintf(buf, PMIU_MAXLINE, 

			   "mcmd=spawn\nnprocs=%d\nexecname=%s\n",

			   maxprocs[spawncnt], cmds[spawncnt] );

	if (rc < 0) {

	    return PMI_FAIL;

	}

	rc = MPL_snprintf(tempbuf, PMIU_MAXLINE,

			   "totspawns=%d\nspawnssofar=%d\n",

			   count, spawncnt+1);

	if (rc < 0) { 

	    return PMI_FAIL;

	}

	rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE);

	if (rc != 0) {

	    return PMI_FAIL;

	}

        argcnt = 0;

        if ((argvs != NULL) && (argvs[spawncnt] != NULL)) {

            for (i=0; argvs[spawncnt][i] != NULL; i++)

            {

		/* FIXME (protocol design flaw): command line arguments

		   may contain both = and <space> (and even tab!).

		*/

		/* Note that part of this fixme was really a design error -

		   because this uses the mcmd form, the data can be

		   sent in multiple writelines.  This code now takes 

		   advantage of that.  Note also that a correct parser 

		   of the commands will permit any character other than a 

		   new line in the argument, since the form is 

		   argn=<any nonnewline><newline> */

                rc = MPL_snprintf(tempbuf,PMIU_MAXLINE,"arg%d=%s\n",

				   i+1,argvs[spawncnt][i]);

		if (rc < 0) {

		    return PMI_FAIL;

		}

                rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE);

		if (rc != 0) {

		    return PMI_FAIL;

		}

                argcnt++;

		rc = PMIU_writeline( PMI_fd, buf );

                if (rc)

                    return PMI_FAIL;

		buf[0] = 0;

            }

        }

        rc = MPL_snprintf(tempbuf,PMIU_MAXLINE,"argcnt=%d\n",argcnt);

	if (rc < 0) {

	    return PMI_FAIL;

	}

        rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE);

	if (rc != 0) {

	    return PMI_FAIL;

	}

        rc = MPL_snprintf(tempbuf,PMIU_MAXLINE,"preput_num=%d\n", 

			   preput_keyval_size);

	if (rc < 0) {

	    return PMI_FAIL;

	}

        rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE);

	if (rc != 0) {

	    return PMI_FAIL;

	}

        for (i=0; i < preput_keyval_size; i++) {

	    rc = MPL_snprintf(tempbuf,PMIU_MAXLINE,"preput_key_%d=%s\n",

			       i,preput_keyval_vector[i].key);

	    if (rc < 0) {

		return PMI_FAIL;

	    }

	    rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE); 

	    if (rc != 0) {

		return PMI_FAIL;

	    }

	    rc = MPL_snprintf(tempbuf,PMIU_MAXLINE,"preput_val_%d=%s\n",

			       i,preput_keyval_vector[i].val);

	    if (rc < 0) {

		return PMI_FAIL;

	    }

	    rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE); 

	    if (rc != 0) {

		return PMI_FAIL;

	    }

        } 

        rc = MPL_snprintf(tempbuf,PMIU_MAXLINE,"info_num=%d\n", 

			   info_keyval_sizes[spawncnt]);

	if (rc < 0) {

	    return PMI_FAIL;

	}

        rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE);

	if (rc != 0) {

	    return PMI_FAIL;

	}

	for (i=0; i < info_keyval_sizes[spawncnt]; i++)

	{

	    rc = MPL_snprintf(tempbuf,PMIU_MAXLINE,"info_key_%d=%s\n",

			       i,info_keyval_vectors[spawncnt][i].key);

	    if (rc < 0) {

		return PMI_FAIL;

	    }

	    rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE); 

	    if (rc != 0) {

		return PMI_FAIL;

	    }

	    rc = MPL_snprintf(tempbuf,PMIU_MAXLINE,"info_val_%d=%s\n",

			       i,info_keyval_vectors[spawncnt][i].val);

	    if (rc < 0) {

		return PMI_FAIL;

	    }

	    rc = MPIU_Strnapp(buf,tempbuf,PMIU_MAXLINE); 

	    if (rc != 0) {

		return PMI_FAIL;

	    }

	}

        rc = MPIU_Strnapp(buf, "endcmd\n", PMIU_MAXLINE);

	if (rc != 0) {

	    return PMI_FAIL;

	}

        rc = PMIU_writeline( PMI_fd, buf );

	if (rc) {

	    return PMI_FAIL;

	}

    }

    PMIU_readline( PMI_fd, buf, PMIU_MAXLINE );

    PMIU_parse_keyvals( buf ); 

    PMIU_getval( "cmd", cmd, PMIU_MAXLINE );

    if ( strncmp( cmd, "spawn_result", PMIU_MAXLINE ) != 0 ) {

	PMIU_printf( 1, "got unexpected response to spawn :%s:\n", buf );

	return( -1 );

    }

    else {

	PMIU_getval( "rc", buf, PMIU_MAXLINE );

	rc = atoi( buf );

	if ( rc != 0 ) {

	    /****

	    PMIU_getval( "status", tempbuf, PMIU_MAXLINE );

	    PMIU_printf( 1, "pmi_spawn_mult failed; status: %s\n",tempbuf);

	    ****/

	    return( -1 );

	}

    }

    PMIU_Assert(errors != NULL);

    if (PMIU_getval( "errcodes", tempbuf, PMIU_MAXLINE )) {

        num_errcodes_found = 0;

        lag = &tempbuf[0];

        do {

            lead = strchr(lag, ',');

            if (lead) *lead = '\0';

            errors[num_errcodes_found++] = atoi(lag);

            lag = lead + 1; /* move past the null char */

            PMIU_Assert(num_errcodes_found <= total_num_processes);

        } while (lead != NULL);

        PMIU_Assert(num_errcodes_found == total_num_processes);

    }

    else {

        /* gforker doesn't return errcodes, so we'll just pretend that means

           that it was going to send all `0's. */

        for (i = 0; i < total_num_processes; ++i) {

            errors[i] = 0;

        }

    }

    return( 0 );

}

/***************** Internal routines not part of PMI interface ***************/

/* to get all maxes in one message */

/* FIXME: This mixes init with get maxes */

static int PMII_getmaxes( int *kvsname_max, int *keylen_max, int *vallen_max )

{

    char buf[PMIU_MAXLINE], cmd[PMIU_MAXLINE], errmsg[PMIU_MAXLINE];

    int err, rc;

    rc = MPL_snprintf( buf, PMIU_MAXLINE, 

			"cmd=init pmi_version=%d pmi_subversion=%d\n",

			PMI_VERSION, PMI_SUBVERSION );

    if (rc < 0) {

	return PMI_FAIL;

    }

    rc = PMIU_writeline( PMI_fd, buf );

    if (rc != 0) {

	PMIU_printf( 1, "Unable to write to PMI_fd\n" );

	return PMI_FAIL;

    }

    buf[0] = 0;   /* Ensure buffer is empty if read fails */

    err = PMIU_readline( PMI_fd, buf, PMIU_MAXLINE );

    if (err < 0) {

	PMIU_printf( 1, "Error reading initack on %d\n", PMI_fd );

	perror( "Error on readline:" );

	PMI_Abort(-1, "Above error when reading after init" );

    }

    PMIU_parse_keyvals( buf );

    cmd[0] = 0;

    PMIU_getval( "cmd", cmd, PMIU_MAXLINE );

    if ( strncmp( cmd, "response_to_init", PMIU_MAXLINE ) != 0 ) {

	MPL_snprintf(errmsg, PMIU_MAXLINE, 

		      "got unexpected response to init :%s: (full line = %s)",

		      cmd, buf  );

	PMI_Abort( -1, errmsg );

    }

    else {

	char buf1[PMIU_MAXLINE];

        PMIU_getval( "rc", buf, PMIU_MAXLINE );

        if ( strncmp( buf, "0", PMIU_MAXLINE ) != 0 ) {

            PMIU_getval( "pmi_version", buf, PMIU_MAXLINE );

            PMIU_getval( "pmi_subversion", buf1, PMIU_MAXLINE );

	    MPL_snprintf(errmsg, PMIU_MAXLINE, 

			  "pmi_version mismatch; client=%d.%d mgr=%s.%s",

			  PMI_VERSION, PMI_SUBVERSION, buf, buf1 );

	    PMI_Abort( -1, errmsg );

        }

    }

    err = GetResponse( "cmd=get_maxes\n", "maxes", 0 );

    if (err == PMI_SUCCESS) {

	PMIU_getval( "kvsname_max", buf, PMIU_MAXLINE );

	*kvsname_max = atoi( buf );

	PMIU_getval( "keylen_max", buf, PMIU_MAXLINE );

	*keylen_max = atoi( buf );

	PMIU_getval( "vallen_max", buf, PMIU_MAXLINE );

	*vallen_max = atoi( buf );

    }

    return err;

}

/* ----------------------------------------------------------------------- */

/* 

 * This function is used to request information from the server and check

 * that the response uses the expected command name.  On a successful

 * return from this routine, additional PMIU_getval calls may be used

 * to access information about the returned value.

 *

 * If checkRc is true, this routine also checks that the rc value returned

 * was 0.  If not, it uses the "msg" value to report on the reason for

 * the failure.

 */

static int GetResponse( const char request[], const char expectedCmd[],

			int checkRc )

{

    int err, n;

    char *p;

    char recvbuf[PMIU_MAXLINE];

    char cmdName[PMIU_MAXLINE];

    /* FIXME: This is an example of an incorrect fix - writeline can change

       the second argument in some cases, and that will break the const'ness

       of request.  Instead, writeline should take a const item and return

       an error in the case in which it currently truncates the data. */

    err = PMIU_writeline( PMI_fd, (char *)request );

    if (err) {

	return err;

    }

    n = PMIU_readline( PMI_fd, recvbuf, sizeof(recvbuf) );

    if (n <= 0) {

	PMIU_printf( 1, "readline failed\n" );

	return PMI_FAIL;

    }

    err = PMIU_parse_keyvals( recvbuf );

    if (err) {

	PMIU_printf( 1, "parse_kevals failed %d\n", err );

	return err;

    }

    p = PMIU_getval( "cmd", cmdName, sizeof(cmdName) );

    if (!p) {

	PMIU_printf( 1, "getval cmd failed\n" );

	return PMI_FAIL;

    }

    if (strcmp( expectedCmd, cmdName ) != 0) {

	PMIU_printf( 1, "expecting cmd=%s, got %s\n", expectedCmd, cmdName );

	return PMI_FAIL;

    }

    if (checkRc) {

	p = PMIU_getval( "rc", cmdName, PMIU_MAXLINE );

	if ( p && strcmp(cmdName,"0") != 0 ) {

	    PMIU_getval( "msg", cmdName, PMIU_MAXLINE );

	    PMIU_printf( 1, "Command %s failed, reason='%s'\n", 

			 request, cmdName );

	    return PMI_FAIL;

	}

    }

    return err;

}

/* ----------------------------------------------------------------------- */

#ifdef USE_PMI_PORT

/*

 * This code allows a program to contact a host/port for the PMI socket.

 */

#include <errno.h>

#if defined(HAVE_SYS_TYPES_H)

#include <sys/types.h>

#endif

#include <sys/param.h>

#include <sys/socket.h>

/* sockaddr_in (Internet) */

#include <netinet/in.h>

/* TCP_NODELAY */

#include <netinet/tcp.h>

/* sockaddr_un (Unix) */

#include <sys/un.h>