void ADIOI_Shfp_fname(ADIO_File fd, int rank, int *error_code) { int len; char *slash, *ptr, tmp[PATH_MAX]; fd->shared_fp_fname = (char *) ADIOI_Malloc(PATH_MAX); if (!rank) { MPL_create_pathname(tmp, NULL, ".shfp", 0); if (ADIOI_Strncpy(fd->shared_fp_fname, fd->filename, PATH_MAX)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", fd->filename, ENAMETOOLONG); return; } #ifdef ROMIO_NTFS slash = strrchr(fd->filename, '\\'); #else slash = strrchr(fd->filename, '/'); #endif if (!slash) { if (ADIOI_Strncpy(fd->shared_fp_fname, ".", 2)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", fd->filename, ENAMETOOLONG); return; } if (ADIOI_Strncpy(fd->shared_fp_fname + 1, fd->filename, PATH_MAX - 1)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", fd->filename, ENAMETOOLONG); return; } } else { ptr = slash; #ifdef ROMIO_NTFS slash = strrchr(fd->shared_fp_fname, '\\'); #else slash = strrchr(fd->shared_fp_fname, '/'); #endif if (ADIOI_Strncpy(slash + 1, ".", 2)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", fd->filename, ENAMETOOLONG); return; } /* ok to cast: file names bounded by PATH_MAX and NAME_MAX */ len = (int) (PATH_MAX - (slash + 2 - fd->shared_fp_fname)); if (ADIOI_Strncpy(slash + 2, ptr + 1, len)) { *error_code = ADIOI_Err_create_code("ADIOI_Shfp_fname", ptr + 1, ENAMETOOLONG); return; } } /* MPL_strnapp will return non-zero if truncated. That's ok */ MPL_strnapp(fd->shared_fp_fname, tmp, PATH_MAX); len = (int) strlen(fd->shared_fp_fname); MPI_Bcast(&len, 1, MPI_INT, 0, fd->comm); MPI_Bcast(fd->shared_fp_fname, len + 1, MPI_CHAR, 0, fd->comm); } else { MPI_Bcast(&len, 1, MPI_INT, 0, fd->comm); MPI_Bcast(fd->shared_fp_fname, len + 1, MPI_CHAR, 0, fd->comm); } }
static int AddEnvSetToCmdLine( const char *envName, const char *envValue, const char **args ) { int nArgs = 0; static int useCSHFormat = -1; /* Determine the Shell type the first time*/ if (useCSHFormat == -1) { char *shell = getenv( "SHELL" ), *sname; if (shell) { /* printf( "Shell is %s\n", shell ); */ sname = strrchr( shell, '/' ); if (!sname) sname = shell; else sname++; /* printf( "Sname is %s\n", sname ); */ if (strcmp( sname, "bash" ) == 0 || strcmp( sname, "sh" ) || strcmp( sname, "ash" ) == 0) useCSHFormat = 0; else useCSHFormat = 1; } else { /* Default is to assume csh (setenv) format */ useCSHFormat = 1; } } if (useCSHFormat) { args[nArgs++] = MPL_strdup( "setenv" ); args[nArgs++] = MPL_strdup( envName ); args[nArgs++] = MPL_strdup( envValue ); args[nArgs++] = MPL_strdup( ";" ); } else { char tmpBuf[1024]; args[nArgs++] = MPL_strdup( "export" ); MPL_strncpy( tmpBuf, envName, sizeof(tmpBuf) ); MPL_strnapp( tmpBuf, "=", sizeof(tmpBuf) ); MPL_strnapp( tmpBuf, envValue, sizeof(tmpBuf) ); args[nArgs++] = MPL_strdup( tmpBuf ); args[nArgs++] = MPL_strdup( ";" ); } return nArgs; }
/* Create a structure that we will use to remember files created for publishing. */ int MPID_NS_Create(const MPIR_Info * info_ptr, MPID_NS_Handle * handle_ptr) { const char *dirname; struct stat st; int err, ret; *handle_ptr = (MPID_NS_Handle) MPL_malloc(sizeof(struct MPID_NS_Handle), MPL_MEM_PM); /* --BEGIN ERROR HANDLING-- */ if (!*handle_ptr) { err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, __func__, __LINE__, MPI_ERR_OTHER, "**nomem", 0); return err; } /* --END ERROR HANDLING-- */ (*handle_ptr)->nactive = 0; (*handle_ptr)->mypid = getpid(); /* Get the dirname. Could use an info value of NAMEPUB_CONTACT */ dirname = MPIR_CVAR_NAMESERV_FILE_PUBDIR; if (!dirname) { /* user did not specify a directory, try using HOME */ ret = MPL_env2str("HOME", &dirname); if (!ret) { /* HOME not found ; use current directory */ dirname = "."; } } MPL_strncpy((*handle_ptr)->dirname, dirname, MAXPATHLEN); MPL_strnapp((*handle_ptr)->dirname, "/.mpinamepub/", MAXPATHLEN); /* Make the directory if necessary */ /* FIXME : Determine if the directory exists before trying to create it */ if (stat((*handle_ptr)->dirname, &st) || !S_ISDIR(st.st_mode)) { /* This mode is rwx by owner only. */ if (mkdir((*handle_ptr)->dirname, 0000700)) { /* FIXME : An error. Ignore most ? * For example, ignore EEXIST? */ ; } } return 0; }
int MPID_NS_Lookup(MPID_NS_Handle handle, const MPIR_Info * info_ptr, const char service_name[], char port[]) { FILE *fp; char filename[MAXPATHLEN]; int mpi_errno = MPI_SUCCESS; /* Determine file and directory name. The file name is from * the service name */ MPL_strncpy(filename, handle->dirname, MAXPATHLEN); MPL_strnapp(filename, service_name, MAXPATHLEN); fp = fopen(filename, "r"); if (!fp) { /* --BEGIN ERROR HANDLING-- */ port[0] = 0; MPIR_ERR_SET1(mpi_errno, MPI_ERR_NAME, "**namepubnotpub", "**namepubnotpub %s", service_name); /* --END ERROR HANDLING-- */ } else { /* The first line is the name, the second is the * process that published. We just read the name */ if (!fgets(port, MPI_MAX_PORT_NAME, fp)) { /* --BEGIN ERROR HANDLING-- */ port[0] = 0; MPIR_ERR_SET1(mpi_errno, MPI_ERR_NAME, "**namepubnotfound", "**namepubnotfound %s", service_name); /* --END ERROR HANDLING-- */ } else { char *nl; /* Remove the newline, if any. We use fgets instead of fscanf * to allow port names to contain blanks */ nl = strchr(port, '\n'); if (nl) *nl = 0; /* printf("Read %s from %s\n", port, filename); */ } fclose(fp); } return mpi_errno; }
int MPID_NS_Unpublish(MPID_NS_Handle handle, const MPIR_Info * info_ptr, const char service_name[]) { char filename[MAXPATHLEN]; int err; int i; /* Remove the file corresponding to the service name */ /* Determine file and directory name. The file name is from * the service name */ MPL_strncpy(filename, handle->dirname, MAXPATHLEN); MPL_strnapp(filename, service_name, MAXPATHLEN); /* Find the filename from the list of published files */ for (i = 0; i < handle->nactive; i++) { if (handle->filenames[i] && strcmp(filename, handle->filenames[i]) == 0) { /* unlink the file only if we find it */ unlink(filename); MPL_free(handle->filenames[i]); handle->filenames[i] = 0; break; } } if (i == handle->nactive) { /* --BEGIN ERROR HANDLING-- */ /* Error: this name was not found */ err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, __func__, __LINE__, MPI_ERR_SERVICE, "**namepubnotpub", "**namepubnotpub %s", service_name); return err; /* --END ERROR HANDLING-- */ } /* Later, we can reduce the number of active and compress the list */ return 0; }
int MPID_NS_Publish(MPID_NS_Handle handle, const MPIR_Info * info_ptr, const char service_name[], const char port[]) { FILE *fp; char filename[MAXPATHLEN]; int err; /* Determine file and directory name. The file name is from * the service name */ MPL_strncpy(filename, handle->dirname, MAXPATHLEN); MPL_strnapp(filename, service_name, MAXPATHLEN); /* Add the file name to the known files now, in case there is * a failure during open or writing */ if (handle->nactive < MPID_MAX_NAMEPUB) { handle->filenames[handle->nactive++] = MPL_strdup(filename); } else { /* --BEGIN ERROR HANDLING-- */ err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, __func__, __LINE__, MPI_ERR_OTHER, "**nomem", 0); return err; /* --END ERROR HANDLING-- */ } /* Now, open the file and write out the port name */ fp = fopen(filename, "w"); /* --BEGIN ERROR HANDLING-- */ if (!fp) { char *reason; /* Generate a better error message */ /* Check for errno = * EACCES (access denied to file or a dir), * ENAMETOOLONG (name too long) * ENOENT (no such directory) * ENOTDIR (a name in the path that should have been a directory * wasn't) * ELOOP (too many symbolic links in path) * ENOMEM (insufficient kernel memory available) * There are a few others that aren't covered here */ #ifdef HAVE_STRERROR reason = strerror(errno); #else /* FIXME : This should use internationalization calls */ switch (errno) { case EACCES: reason = "Access denied to some element of the path"; break; case ENAMETOOLONG: reason = "File name is too long"; break; case ENOENT: reason = "A directory specified in the path does not exist"; break; case ENOTDIR: reason = "A name specified in the path exists, but is not a directory and is used where a directory is required"; break; case ENOMEM: reason "Insufficient kernel memory available"; default: MPL_snprintf(rstr, sizeof(rstr), "errno = %d", errno); } #endif err = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, __func__, __LINE__, MPI_ERR_OTHER, "**namepubfile", "**namepubfile %s %s %s", service_name, filename, reason); return err; } /* --END ERROR HANDLING-- */ /* Should also add date? */ fprintf(fp, "%s\n%d\n", port, handle->mypid); fclose(fp); return 0; }