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

/*

 *

 *  (C) 2006 by Argonne National Laboratory.

 *      See COPYRIGHT in top-level directory.

 */

/* Test of MPI_Comm_join.  This should work even when each process

 * is started as a singleton process.

 *

 * To run

 *

 * Start the server:

 *

 * ./singjoin -s -p 54321

 *

 * In a separate shell, start the client:

 *

 * ./singjoin -c -p 54321

 *

 * where "54321" is some available port number.

 */

/* Include mpitestconf to determine if we can use h_addr or need h_addr_list */

#include "mpitestconf.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifndef HAVE_WINDOWS_H

#include <strings.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#else

#include <windows.h>

#endif

#include <mpi.h>

#ifndef HAVE_WINDOWS_H

#define SOCKET_FD_TYPE int

#define INVALID_SOCKET_FD -1

#else

#define SOCKET_FD_TYPE  SOCKET

#define INVALID_SOCKET_FD INVALID_SOCKET

#define bcopy(s1, s2, n)    memmove(s2, s1, n)

#endif

int parse_args(int argc, char **argv);

void usage(char *name);

SOCKET_FD_TYPE server_routine(int portnum);

SOCKET_FD_TYPE client_routine(int portnum);

int is_server = 0;

int is_client = 0;

int opt_port = 0;

/* open a socket, establish a connection with a client, and return the fd */

SOCKET_FD_TYPE server_routine(int portnum)

{

    SOCKET_FD_TYPE listenfd, peer_fd;

    int ret, peer_addr_size;

    struct sockaddr_in server_addr, peer_addr;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    if (listenfd == INVALID_SOCKET_FD) {

        perror("server socket");

        return -1;

    }

    memset(&server_addr, 0, sizeof(server_addr));

    server_addr.sin_family = AF_INET;

    server_addr.sin_addr.s_addr = INADDR_ANY;

    server_addr.sin_port = htons(portnum);

    ret = bind(listenfd, (struct sockaddr *) &server_addr, sizeof(server_addr));

    if (ret < 0) {

        perror("server binding");

        return -1;

    }

    ret = listen(listenfd, 1024);

    if (ret < 0) {

        perror("server listen");

        return -1;

    }

    peer_addr_size = sizeof(peer_addr);

    peer_fd = accept(listenfd, (struct sockaddr *) &peer_addr, &peer_addr_size);

    if (peer_fd < 0) {

        perror("server accept");

        return -1;

    }

    return peer_fd;

}

/* open a socket, establish a connection with a server, and return the fd */

SOCKET_FD_TYPE client_routine(int portnum)

{

    SOCKET_FD_TYPE sockfd;

    struct sockaddr_in server_addr;

    struct hostent *server_ent;

    char hostname[MPI_MAX_PROCESSOR_NAME];

    int hostnamelen;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (sockfd == INVALID_SOCKET_FD) {

        perror("client socket");

        return -1;

    }

    /* Try to get the processor name from MPI */

    MPI_Get_processor_name(hostname, &hostnamelen);

    server_ent = gethostbyname(hostname);

    if (server_ent == NULL) {

        fprintf(stderr, "gethostbyname fails\n");

        return -1;

    }

    memset(&server_addr, 0, sizeof(server_addr));

    server_addr.sin_family = AF_INET;

    server_addr.sin_port = htons(portnum);

    /* POSIX might define h_addr_list only and not define h_addr */

#ifdef HAVE_H_ADDR_LIST

    bcopy(server_ent->h_addr_list[0], (char *) &server_addr.sin_addr.s_addr, server_ent->h_length);

#else

    bcopy(server_ent->h_addr, (char *) &server_addr.sin_addr.s_addr, server_ent->h_length);

#endif

    if (connect(sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0) {

        perror("client connect");

        return -1;

    }

    return sockfd;

}

void usage(char *name)

{

    fprintf(stderr, "usage: %s [-s|-c] -p <PORT>\n", name);

    fprintf(stderr, "      specify one and only one of -s or -c\n");

    fprintf(stderr, "      port is mandatory\n");

}

#ifdef HAVE_WINDOWS_H

static int get_option(int argc, char **argv, int arg_cnt)

{

    if (argv == NULL) {

        return -1;

    }

    if (*argv == NULL) {

        return -1;

    }

    if (arg_cnt < 0 || arg_cnt >= argc) {

        return -1;

    }

    if (strlen(argv[arg_cnt]) < 2) {

        return -1;

    }

    return (*(argv[arg_cnt] + 1));

}

#endif

int parse_args(int argc, char **argv)

{

#ifndef HAVE_WINDOWS_H

    int c;

    extern char *optarg;

    while ((c = getopt(argc, argv, "csp:")) != -1) {

        switch (c) {

        case 's':

            is_server = 1;

            break;

        case 'c':

            is_client = 1;

            break;

        case 'p':

            opt_port = atoi(optarg);

            break;

        case '?':

        case ':':

        default:

            usage(argv[0]);

            return -1;

        }

    }

    if ((is_client == 0) && (is_server == 0)) {

        usage(argv[0]);

        return -1;

    }

    if (opt_port == 0) {

        usage(argv[0]);

        return -1;

    }

    return 0;

#else

    int arg_cnt = 1;

    int c;

    while ((c = get_option(argc, argv, arg_cnt++)) > 0) {

        switch (c) {

        case 's':

            is_server = 1;

            break;

        case 'c':

            is_client = 1;

            break;

        case 'p':

            opt_port = atoi(argv[arg_cnt++]);

            break;

        default:

            usage(argv[0]);

            return -1;

        }

    }

    if ((is_client == 0) && (is_server == 0)) {

        usage(argv[0]);

        return -1;

    }

    if (opt_port == 0) {

        usage(argv[0]);

        return -1;

    }

    return 0;

#endif

}

int main(int argc, char **argv)

{

    int rank, size;

    SOCKET_FD_TYPE fd = INVALID_SOCKET_FD;

    MPI_Comm intercomm, intracomm;

    MPI_Init(&argc, &argv);

    MPI_Comm_size(MPI_COMM_WORLD, &size);

    if (size != 1) {

        fprintf(stderr, "This test requires that only one process be in each comm_world\n");

        MPI_Abort(MPI_COMM_WORLD, 1);

    }

    if (parse_args(argc, argv) == -1) {

        fprintf(stderr, "Unable to parse the command line arguments\n");

        MPI_Abort(MPI_COMM_WORLD, 1);

    }

    if (is_server) {

        fd = server_routine(opt_port);

    }

    else if (is_client) {

        fd = client_routine(opt_port);

    }

    if (fd == INVALID_SOCKET_FD) {

        return -1;

    }

#ifdef SINGLETON_KICK

/* #warning isn't standard C, so we comment out this directive */

/* #warning  using singleton workaround */

    {

        int *usize, aflag;

        MPI_Comm_get_attr(MPI_COMM_WORLD, MPI_UNIVERSE_SIZE, &usize, &aflag);

    }

#endif

    MPI_Comm_join(fd, &intercomm);

    if (is_server) {

        MPI_Send(MPI_BOTTOM, 0, MPI_INT, 0, 0, intercomm);

    }

    else {

        MPI_Recv(MPI_BOTTOM, 0, MPI_INT, 0, 0, intercomm, MPI_STATUS_IGNORE);

        printf("Completed receive on intercomm\n");

        fflush(stdout);

    }

    MPI_Intercomm_merge(intercomm, 0, &intracomm);

    MPI_Comm_rank(intracomm, &rank;;

    MPI_Comm_size(intracomm, &size);

    printf("[%d/%d] after Intercomm_merge\n", rank, size);

    MPI_Comm_free(&intracomm);

    MPI_Comm_disconnect(&intercomm);

    MPI_Finalize();

    return 0;

}