static pmix_status_t send_connect_ack(int sd) { char *msg; pmix_usock_hdr_t hdr; size_t sdsize=0, csize=0; pmix_byte_object_t cred; pmix_status_t rc; char *sec, *bfrops, *gds; pmix_bfrop_buffer_type_t bftype; pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "pmix: SEND CONNECT ACK"); /* setup the header */ memset(&hdr, 0, sizeof(pmix_usock_hdr_t)); hdr.pindex = -1; hdr.tag = UINT32_MAX; /* reserve space for the nspace and rank info */ sdsize = strlen(pmix_globals.myid.nspace) + 1 + sizeof(int); /* get a credential, if the security system provides one. Not * every SPC will do so, thus we must first check */ PMIX_BYTE_OBJECT_CONSTRUCT(&cred); PMIX_PSEC_CREATE_CRED(rc, pmix_globals.mypeer, NULL, 0, NULL, 0, &cred); if (PMIX_SUCCESS != rc) { return rc; } /* add the name of our active sec module - we selected it * in pmix_client.c prior to entering here */ sec = pmix_globals.mypeer->nptr->compat.psec->name; /* add our active bfrops module name */ bfrops = pmix_globals.mypeer->nptr->compat.bfrops->version; /* and the type of buffer we are using */ bftype = pmix_globals.mypeer->nptr->compat.type; /* add our active gds module for working with the server */ gds = (char*)pmix_client_globals.myserver->nptr->compat.gds->name; /* set the number of bytes to be read beyond the header */ hdr.nbytes = sdsize + (strlen(PMIX_VERSION) + 1) + \ (sizeof(size_t) + cred.size) + \ (strlen(sec) + 1) + \ (strlen(bfrops) + 1) + sizeof(bftype) + \ (strlen(gds) + 1); // must NULL terminate the strings! /* create a space for our message */ sdsize = (sizeof(hdr) + hdr.nbytes); if (NULL == (msg = (char*)malloc(sdsize))) { PMIX_BYTE_OBJECT_DESTRUCT(&cred); return PMIX_ERR_OUT_OF_RESOURCE; } memset(msg, 0, sdsize); /* load the message */ csize=0; memcpy(msg, &hdr, sizeof(pmix_usock_hdr_t)); csize += sizeof(pmix_usock_hdr_t); /* pass our nspace */ memcpy(msg+csize, pmix_globals.myid.nspace, strlen(pmix_globals.myid.nspace)); csize += strlen(pmix_globals.myid.nspace)+1; /* pass our rank */ memcpy(msg+csize, &pmix_globals.myid.rank, sizeof(int)); csize += sizeof(int); /* pass our version string */ memcpy(msg+csize, PMIX_VERSION, strlen(PMIX_VERSION)); csize += strlen(PMIX_VERSION)+1; /* pass the size of the credential */ memcpy(msg+csize, &cred.size, sizeof(size_t)); csize += sizeof(size_t); if (0 < cred.size) { memcpy(msg+csize, cred.bytes, cred.size); csize += cred.size; } PMIX_BYTE_OBJECT_DESTRUCT(&cred); /* pass our active sec module */ memcpy(msg+csize, sec, strlen(sec)); csize += strlen(sec)+1; /* provide our active bfrops module */ memcpy(msg+csize, bfrops, strlen(bfrops)); csize += strlen(bfrops)+1; /* provide the bfrops type */ memcpy(msg+csize, &bftype, sizeof(bftype)); csize += sizeof(bftype); /* provide the gds module */ memcpy(msg+csize, gds, strlen(gds)); /* send the entire msg across */ if (PMIX_SUCCESS != pmix_ptl_base_send_blocking(sd, msg, sdsize)) { free(msg); return PMIX_ERR_UNREACH; } free(msg); return PMIX_SUCCESS; }
/**** SUPPORTING FUNCTIONS ****/ static pmix_status_t send_connect_ack(int sd) { char *msg; pmix_ptl_hdr_t hdr; size_t sdsize=0, csize=0, len; char *cred = NULL; char *sec; pmix_status_t rc; uint8_t flag; uid_t euid; gid_t egid; uint32_t u32; pmix_output_verbose(2, pmix_globals.debug_output, "pmix:tcp SEND CONNECT ACK"); /* if we are a server, then we shouldn't be here */ if (PMIX_PROC_IS_SERVER) { return PMIX_ERR_NOT_SUPPORTED; } /* setup the header */ memset(&hdr, 0, sizeof(pmix_ptl_hdr_t)); hdr.pindex = -1; hdr.tag = UINT32_MAX; /* a security module was assigned to us during rte_init based * on a list of available security modules provided by our * local PMIx server, if known. Now use that module to * get a credential, if the security system provides one. Not * every psec module will do so, thus we must first check */ if (PMIX_SUCCESS != (rc = pmix_psec.create_cred(&pmix_client_globals.myserver, PMIX_PROTOCOL_V2, &cred, &len))) { return rc; } /* allow space for a marker indicating client vs tool */ sdsize = 1; if (PMIX_PROC_IS_CLIENT) { flag = 0; /* reserve space for our nspace and rank info */ sdsize += strlen(pmix_globals.myid.nspace) + 1 + sizeof(int); } else { flag = 1; /* add space for our uid/gid for ACL purposes */ sdsize += 2*sizeof(uint32_t); } /* add our active sec module info */ sec = pmix_psec.get_available_modules(); /* set the number of bytes to be read beyond the header */ hdr.nbytes = sdsize + strlen(PMIX_VERSION) + 1 + strlen(sec) + 1 + sizeof(uint32_t) + len; // must NULL terminate the VERSION string! /* create a space for our message */ sdsize = (sizeof(hdr) + hdr.nbytes); if (NULL == (msg = (char*)malloc(sdsize))) { if (NULL != cred) { free(cred); } free(sec); return PMIX_ERR_OUT_OF_RESOURCE; } memset(msg, 0, sdsize); /* load the message */ csize=0; memcpy(msg, &hdr, sizeof(pmix_ptl_hdr_t)); csize += sizeof(pmix_ptl_hdr_t); /* provide our active psec module */ memcpy(msg+csize, sec, strlen(sec)); csize += strlen(sec)+1; free(sec); /* load the length of the credential - we put this in uint32_t * format as that is a fixed size, and convert to network * byte order for heterogeneity */ u32 = htonl((uint32_t)len); memcpy(msg+csize, &u32, sizeof(uint32_t)); csize += sizeof(uint32_t); /* load the credential */ if (0 < u32) { memcpy(msg+csize, cred, len); csize += len; } /* load our process type - this is a single byte, * so no worry about heterogeneity here */ memcpy(msg+csize, &flag, 1); csize += 1; if (PMIX_PROC_IS_CLIENT) { /* if we are a client, provide our nspace/rank */ memcpy(msg+csize, pmix_globals.myid.nspace, strlen(pmix_globals.myid.nspace)); csize += strlen(pmix_globals.myid.nspace)+1; /* again, need to convert */ u32 = htonl((uint32_t)pmix_globals.myid.rank); memcpy(msg+csize, &u32, sizeof(uint32_t)); csize += sizeof(uint32_t); } else { /* if we are a tool, provide our uid/gid for ACL support - note * that we have to convert so we can handle heterogeneity */ euid = geteuid(); u32 = htonl(euid); memcpy(msg+csize, &u32, sizeof(uint32_t)); csize += sizeof(uint32_t); egid = getegid(); u32 = htonl(egid); memcpy(msg+csize, &u32, sizeof(uint32_t)); csize += sizeof(uint32_t); } /* provide our version */ memcpy(msg+csize, PMIX_VERSION, strlen(PMIX_VERSION)); csize += strlen(PMIX_VERSION)+1; /* send the entire message across */ if (PMIX_SUCCESS != pmix_ptl_base_send_blocking(sd, msg, sdsize)) { free(msg); if (NULL != cred) { free(cred); } return PMIX_ERR_UNREACH; } free(msg); if (NULL != cred) { free(cred); } return PMIX_SUCCESS; }
static pmix_status_t send_connect_ack(int sd) { char *msg; pmix_ptl_hdr_t hdr; size_t sdsize=0, csize=0; pmix_byte_object_t cred; char *sec, *bfrops, *gds; pmix_bfrop_buffer_type_t bftype; pmix_status_t rc; uint8_t flag; uid_t euid; gid_t egid; uint32_t u32; pmix_output_verbose(2, pmix_ptl_base_framework.framework_output, "pmix:tcp SEND CONNECT ACK"); /* if we are a server, then we shouldn't be here */ if (PMIX_PROC_IS_SERVER(pmix_globals.mypeer)) { return PMIX_ERR_NOT_SUPPORTED; } /* setup the header */ memset(&hdr, 0, sizeof(pmix_ptl_hdr_t)); hdr.pindex = -1; hdr.tag = UINT32_MAX; /* a security module was assigned to us during rte_init based * on a list of available security modules provided by our * local PMIx server, if known. Now use that module to * get a credential, if the security system provides one. Not * every psec module will do so, thus we must first check */ PMIX_BYTE_OBJECT_CONSTRUCT(&cred); PMIX_PSEC_CREATE_CRED(rc, pmix_globals.mypeer, NULL, 0, NULL, 0, &cred); if (PMIX_SUCCESS != rc) { pmix_output(0, "OUCH: %d", __LINE__); return rc; } /* allow space for a marker indicating client vs tool */ sdsize = 1; if (PMIX_PROC_IS_CLIENT(pmix_globals.mypeer)) { flag = 0; /* reserve space for our nspace and rank info */ sdsize += strlen(pmix_globals.myid.nspace) + 1 + sizeof(int); } else { flag = 1; /* add space for our uid/gid for ACL purposes */ sdsize += 2*sizeof(uint32_t); } /* add the name of our active sec module - we selected it * in pmix_client.c prior to entering here */ sec = pmix_globals.mypeer->nptr->compat.psec->name; /* add our active bfrops module name */ bfrops = pmix_globals.mypeer->nptr->compat.bfrops->version; /* and the type of buffer we are using */ bftype = pmix_globals.mypeer->nptr->compat.type; /* add our active gds module for working with the server */ gds = (char*)pmix_client_globals.myserver->nptr->compat.gds->name; /* set the number of bytes to be read beyond the header */ hdr.nbytes = sdsize + strlen(PMIX_VERSION) + 1 + strlen(sec) + 1 \ + strlen(bfrops) + 1 + sizeof(bftype) \ + strlen(gds) + 1 + sizeof(uint32_t) + cred.size; // must NULL terminate the strings! /* create a space for our message */ sdsize = (sizeof(hdr) + hdr.nbytes); if (NULL == (msg = (char*)malloc(sdsize))) { PMIX_BYTE_OBJECT_DESTRUCT(&cred); free(sec); return PMIX_ERR_OUT_OF_RESOURCE; } memset(msg, 0, sdsize); /* load the message */ csize=0; memcpy(msg, &hdr, sizeof(pmix_ptl_hdr_t)); csize += sizeof(pmix_ptl_hdr_t); /* provide our active psec module */ memcpy(msg+csize, sec, strlen(sec)); csize += strlen(sec)+1; /* load the length of the credential - we put this in uint32_t * format as that is a fixed size, and convert to network * byte order for heterogeneity */ u32 = htonl((uint32_t)cred.size); memcpy(msg+csize, &u32, sizeof(uint32_t)); csize += sizeof(uint32_t); /* load the credential */ if (0 < u32) { memcpy(msg+csize, cred.bytes, cred.size); csize += cred.size; } PMIX_BYTE_OBJECT_DESTRUCT(&cred); /* load our process type - this is a single byte, * so no worry about heterogeneity here */ memcpy(msg+csize, &flag, 1); csize += 1; if (PMIX_PROC_IS_CLIENT(pmix_globals.mypeer)) { /* if we are a client, provide our nspace/rank */ memcpy(msg+csize, pmix_globals.myid.nspace, strlen(pmix_globals.myid.nspace)); csize += strlen(pmix_globals.myid.nspace)+1; /* again, need to convert */ u32 = htonl((uint32_t)pmix_globals.myid.rank); memcpy(msg+csize, &u32, sizeof(uint32_t)); csize += sizeof(uint32_t); } else { /* if we are a tool, provide our uid/gid for ACL support - note * that we have to convert so we can handle heterogeneity */ euid = geteuid(); u32 = htonl(euid); memcpy(msg+csize, &u32, sizeof(uint32_t)); csize += sizeof(uint32_t); egid = getegid(); u32 = htonl(egid); memcpy(msg+csize, &u32, sizeof(uint32_t)); csize += sizeof(uint32_t); } /* provide our version */ memcpy(msg+csize, PMIX_VERSION, strlen(PMIX_VERSION)); csize += strlen(PMIX_VERSION)+1; /* provide our active bfrops module */ memcpy(msg+csize, bfrops, strlen(bfrops)); csize += strlen(bfrops)+1; /* provide the bfrops type */ memcpy(msg+csize, &bftype, sizeof(bftype)); csize += sizeof(bftype); /* provide the gds module */ memcpy(msg+csize, gds, strlen(gds)); csize += strlen(gds)+1; /* send the entire message across */ if (PMIX_SUCCESS != pmix_ptl_base_send_blocking(sd, msg, sdsize)) { free(msg); return PMIX_ERR_UNREACH; } free(msg); return PMIX_SUCCESS; }
static pmix_status_t send_connect_ack(int sd) { char *msg; pmix_usock_hdr_t hdr; size_t sdsize=0, csize=0, len; char *cred = NULL; pmix_status_t rc; pmix_output_verbose(2, pmix_globals.debug_output, "pmix: SEND CONNECT ACK"); /* setup the header */ memset(&hdr, 0, sizeof(pmix_usock_hdr_t)); hdr.pindex = -1; hdr.tag = UINT32_MAX; /* reserve space for the nspace and rank info */ sdsize = strlen(pmix_globals.myid.nspace) + 1 + sizeof(int); /* get a credential, if the security system provides one. Not * every SPC will do so, thus we must first check */ PMIX_PSEC_CREATE_CRED(rc, pmix_client_globals.myserver, PMIX_PROTOCOL_V1, &cred, &len); if (PMIX_SUCCESS != rc) { return rc; } /* set the number of bytes to be read beyond the header */ hdr.nbytes = sdsize + strlen(PMIX_VERSION) + 1 + len; // must NULL terminate the VERSION string! /* create a space for our message */ sdsize = (sizeof(hdr) + hdr.nbytes); if (NULL == (msg = (char*)malloc(sdsize))) { if (NULL != cred) { free(cred); } return PMIX_ERR_OUT_OF_RESOURCE; } memset(msg, 0, sdsize); /* load the message */ csize=0; memcpy(msg, &hdr, sizeof(pmix_usock_hdr_t)); csize += sizeof(pmix_usock_hdr_t); memcpy(msg+csize, pmix_globals.myid.nspace, strlen(pmix_globals.myid.nspace)); csize += strlen(pmix_globals.myid.nspace)+1; memcpy(msg+csize, &pmix_globals.myid.rank, sizeof(int)); csize += sizeof(int); memcpy(msg+csize, PMIX_VERSION, strlen(PMIX_VERSION)); csize += strlen(PMIX_VERSION)+1; if (NULL != cred) { memcpy(msg+csize, cred, strlen(cred)); // leaves last position in msg set to NULL } if (PMIX_SUCCESS != pmix_ptl_base_send_blocking(sd, msg, sdsize)) { free(msg); if (NULL != cred) { free(cred); } return PMIX_ERR_UNREACH; } free(msg); if (NULL != cred) { free(cred); } return PMIX_SUCCESS; }