int filemngt_create_file_space(char *filename, size_t size, void **buffer_out, int *fd_out)
{
   int result;
   *fd_out = open(filename, O_CREAT | O_EXCL | O_RDWR, 0700);
   if (*fd_out == -1) {
      err_printf("Could not create local file %s: %s\n", filename, strerror(errno));
      return -1;
   }
   if (size == 0) {
       size = getpagesize();
       debug_printf2("growing empty file to size %d", (int) size);
   }
   result = ftruncate(*fd_out, size);
   if (result == -1) {
      err_printf("Could not grow local file %s to %lu (out of memory?): %s\n", filename, size, strerror(errno));
      close(*fd_out);
      return -1;
   }
   *buffer_out = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, *fd_out, 0);
   if (*buffer_out == MAP_FAILED) {
      err_printf("Could not mmap file %s: %s\n", filename, strerror(errno));
      close(*fd_out);
      return -1;
   }
   assert(*buffer_out);
   return 0;
}
Exemple #2
0
int ldcs_audit_server_fe_md_open ( char **hostlist, int numhosts, unsigned int port, unsigned int num_ports,
                                   unsigned int shared_secret, 
                                   void **data  ) {
   int rc=0;
   int *portlist;
   int root_fd, ack;
   int i;

   assert(num_ports >= 1);
   portlist = malloc(sizeof(int) * (num_ports+1));
   for (i = 0; i < num_ports; i++) {
      portlist[i] = port + i;
   }
   portlist[num_ports] = 0;

   debug_printf2("Opening with port %d - %d\n", portlist[0], portlist[num_ports-1]);
   cobo_server_open(shared_secret, hostlist, numhosts, portlist, num_ports);
   free(portlist);

   cobo_server_get_root_socket(&root_fd);
  
   ldcs_cobo_read_fd(root_fd, &ack, sizeof(ack));

   return(rc);
}
Exemple #3
0
static ssize_t readlink_worker(const char *path, char *buf, size_t bufsiz,
                               char *newbuf, ssize_t rl_result)
{
   char newpath[MAX_PATH_LEN+1];
   char spindle_id[32];
   int location_len;

   location_len = strlen(location);   
   snprintf(spindle_id, sizeof(spindle_id), "spindle.%d", number);

   if (!strstr(newbuf, spindle_id) ||
       strncmp(location, newbuf, location_len) != 0) {
      debug_printf3("readlink not intercepting, %s not prefixed by %s\n", newbuf, location);
      int len = strlen(newbuf);
      if (len > bufsiz)
         len = bufsiz;
      memcpy(buf, newbuf, len);
      return len;
   }

   send_orig_path_request(ldcsid, newbuf+location_len+1, newpath);
   int len = strlen(newpath);
   if (len > bufsiz)
      len = bufsiz;
   memcpy(buf, newpath, len);
   debug_printf2("readlink translated %s to %s to %s\n", path, newbuf, newpath);
   return len;
}
Exemple #4
0
int get_existance_test(int fd, const char *path, int *exists)
{
   int use_cache = (opts & OPT_SHMCACHE) && (shm_cachesize > 0);
   int found_file, result;
   char cache_name[MAX_PATH_LEN+2];
   char *exist_str;

   if (use_cache) {
      debug_printf2("Looking up file existance for %s in shared cache\n", path);
      get_cache_name(path, "&", cache_name);
      cache_name[sizeof(cache_name)-1] = '\0';
      found_file = fetch_from_cache(cache_name, &exist_str);
      if (found_file) {
         *exists = (exist_str[0] == 'y');
         return 0;
      }
   }

   result = send_existance_test(fd, (char *) path, exists);
   if (result == -1)
      return -1;

   if (use_cache) {
      exist_str = *exists ? "y" : "n";
      shmcache_update(cache_name, exist_str);
   }
   return 0;
}
int ldcs_audit_server_md_init(unsigned int port, unsigned int num_ports, 
                              unique_id_t unique_id, ldcs_process_data_t *data)
{
   int rc=0;
   unsigned int *portlist;
   int my_rank, ranks, fanout;
   int i;

   portlist = malloc(sizeof(unsigned int) * (num_ports + 1));
   for (i = 0; i < num_ports; i++) {
      portlist[i] = port + i;
   }
   portlist[num_ports] = 0;

   /* initialize the client (read environment variables) */
   debug_printf2("Opening cobo with port %d - %d\n", portlist[0], portlist[num_ports-1]);
   if (cobo_open(unique_id, (int *) portlist, num_ports, &my_rank, &ranks) != COBO_SUCCESS) {
      printf("Failed to init\n");
      exit(1);
   }
   debug_printf2("cobo_open complete. Cobo rank %d/%d\n", my_rank, ranks);
   free(portlist);

   data->server_stat.md_rank = data->md_rank = my_rank;
   data->server_stat.md_size = data->md_size = ranks;
   data->md_listen_to_parent = 0;

   cobo_get_num_childs(&fanout);
   data->server_stat.md_fan_out = data->md_fan_out = fanout;

   cobo_barrier();

   /* send ack about being ready */
   if (data->md_rank == 0) { 
      int root_fd, ack=13;

      /* send fe client signal to stop (ack)  */
      cobo_get_parent_socket(&root_fd);
    
      ldcs_cobo_write_fd(root_fd, &ack, sizeof(ack));
      debug_printf3("sent FE client signal that server are ready %d\n",ack);
   }
  
   return(rc);
}
void *filemngt_sync_file_space(void *buffer, int fd, char *pathname, size_t size, size_t newsize)
{
   /* Linux gets annoying here.  We can't just mprotect the buffer to read-only,
      Linux considers the file still open for writing (and thus throws ETXTBUSY on exec's)
      as long as we still have the buffer mmaped from a fd that was opened with write.
      That means we've got to close the file, unmap the buffer, then re-open the file 
      read-only, then re-map the buffer to the same place.  Ugh.  
   */

   int result;
   char *buffer2;

   if (size == 0) {
       newsize = size = getpagesize();
       debug_printf2("growing empty file to size %d", (int) size);
   }

   result = munmap(buffer, size);
   if (result == -1) {
      err_printf("Error unmapping buffer for %s\n", pathname);
      return NULL;
   }

   if (size != newsize) {
      assert(newsize < size);
      /* The file shrunk after we read it, probably because we stripped it
         as we read.  Shrink the local file on disk and shrink the mapped region */
      result = ftruncate(fd, newsize);
      if (result == -1) {
         err_printf("Could not shrink file in local disk\n");
         return NULL;
      }
   }
   
   close(fd);
   
   fd = open(pathname, O_RDONLY);
   if (fd == -1) {
      err_printf("Failed to re-open file %s: %s\n", pathname, strerror(errno));
      return NULL;
   }
   
   buffer2 = mmap(buffer, newsize, PROT_READ, MAP_SHARED | MAP_FIXED, fd, 0);
   if (buffer2 == MAP_FAILED) {
      debug_printf("Failure re-mapping file %s: %s. Retrying.\n", pathname, strerror(errno));
      buffer2 = mmap(NULL, newsize, PROT_READ, MAP_SHARED, fd, 0);
      if (buffer2 == MAP_FAILED) {
         debug_printf("Could not re-mapping file %s: %s\n", pathname, strerror(errno));
         return NULL;
      }
   }

   close(fd);

   return buffer2;
}
int filemngt_read_file(char *filename, void *buffer, size_t *size, int strip, int *errcode)
{
   FILE *f;
   int result = 0;

   debug_printf2("Reading file %s from disk\n", filename);
   f = fopen(filename, "r");
   if (!f) {
      *errcode = errno;
      debug_printf2("Could not read file %s from disk, errcode = %d\n", filename, *errcode);
      return 0;
   }

   result = read_file_and_strip(f, buffer, size, strip);
   if (result == -1)
      err_printf("Error reading from file %s: %s\n", filename, strerror(errno));

   fclose(f);
   return result;
}
Exemple #8
0
int client_done()
{
   check_for_fork();
   if (ldcsid == -1 || !use_ldcs)
      return 0;

   debug_printf2("Done. Closing connection %d\n", ldcsid);
   send_end(ldcsid);
   client_close_connection(ldcsid);
   return 0;
}
Exemple #9
0
void patch_on_load_success(const char *rewritten_name, const char *orig_name)
{
   if (!(opts & OPT_DEBUG)) {
      return;
   }

   if (last_orig_name)
      spindle_free(last_orig_name);

   last_rewritten_name = (char *) rewritten_name;
   last_orig_name = spindle_strdup(orig_name);
   debug_printf2("Patching link map %s -> %s\n", rewritten_name, orig_name);
}
size_t filemngt_get_file_size(char *pathname, int *errcode)
{
   struct stat st;
   int result;

   result = stat(pathname, &st);
   if (result == -1) {
      if (errcode)
         *errcode = errno;
      debug_printf2("Could not stat file %s, perhaps bad symlink\n", pathname);
      return (size_t) -1;
   }
   return (size_t) st.st_size;
}
Exemple #11
0
int get_relocated_file(int fd, const char *name, char** newname, int *errorcode)
{
   int found_file = 0;
   int use_cache = (opts & OPT_SHMCACHE) && (shm_cachesize > 0);
   char cache_name[MAX_PATH_LEN+1];

   if (use_cache) {
      debug_printf2("Looking up %s in shared cache\n", name);
      get_cache_name(name, "", cache_name);
      cache_name[sizeof(cache_name)-1] = '\0';
      found_file = fetch_from_cache(cache_name, newname);
   }

   if (!found_file) {
      debug_printf2("Send file request to server: %s\n", name);
      send_file_query(fd, (char *) name, newname, errorcode);
      debug_printf2("Recv file from server: %s\n", *newname ? *newname : "NONE");      
      if (use_cache)
         shmcache_update(cache_name, *newname);
   }

   return 0;
}
Exemple #12
0
static int execvp_wrapper(const char *path, char *const argv[])
{
   char newpath[MAX_PATH_LEN+1];
   char **new_argv = NULL;
   int result, error;

   debug_printf2("Intercepted execvp on %s\n", path);
   find_exec_pathsearch(path, (char **) argv, newpath, MAX_PATH_LEN+1, &new_argv);
   debug_printf("execvp redirection of %s to %s\n", path, newpath);
   result = orig_execvp(newpath, new_argv ? new_argv : argv);
   error = errno;
   if (new_argv)
      spindle_free(new_argv);
   set_errno(error);
   return result;
}
Exemple #13
0
int readlinkat_wrapper(int dirfd, const char *path, char *buf, size_t bufsiz)
{
   char newbuf[MAX_PATH_LEN+1];
   ssize_t rl_result;
   debug_printf2("Intercepted readlink on %s\n", path);

   check_for_fork();

   memset(newbuf, 0, MAX_PATH_LEN+1);
   rl_result = (ssize_t) orig_readlinkat(dirfd, path, newbuf, MAX_PATH_LEN);
   if (rl_result == -1) {
      return -1;
   }

   return (int) readlink_worker(path, buf, bufsiz, newbuf, rl_result);   
}
Exemple #14
0
int get_ldso_metadata(signed int *binding_offset)
{
   ldso_info_t info;
   int result;
   char filename[MAX_PATH_LEN+1];

   find_interp_name();
   debug_printf2("Requesting interpreter metadata for %s\n", interp_name);
   result = send_ldso_info_request(ldcsid, interp_name, filename);
   if (result == -1)
      return -1;

   read_ldso_metadata(filename, &info);

   *binding_offset = info.binding_offset;
   return 0;
}
Exemple #15
0
static int execlp_wrapper(const char *path, const char *arg0, ...)
{
   int error, result;
   char newpath[MAX_PATH_LEN+1];

   VARARG_TO_ARGV;
   debug_printf2("Intercepted execlp on %s\n", path);
   find_exec_pathsearch(path, argv, newpath, MAX_PATH_LEN+1, &new_argv);
   debug_printf("execlp redirection of %s to %s\n", path, newpath);
   result = execv(newpath, new_argv ? new_argv : argv);
   error = errno;

   VARARG_TO_ARGV_CLEANUP;

   set_errno(error);
   return result;
}
Exemple #16
0
int ldcs_recv_msg_static_pipe(int fd, ldcs_message_t *msg, ldcs_read_block_t block) {
  int n;
  int rc=0;
  msg->header.type=LDCS_MSG_UNKNOWN;
  msg->header.len=0;
  if ((fd<0) || (fd>fdlist_pipe_size) )  _error("wrong fd");

  n = _ldcs_read_pipe(fdlist_pipe[fd].in_fd,&msg->header,sizeof(msg->header), block);
  if (n == 0) {
     /* Disconnect.  Return an artificial client end message */
     debug_printf2("Client disconnected.  Returning END message\n");
     msg->header.type = LDCS_MSG_END;
     msg->header.len = 0;
     msg->data = NULL;
     return(rc);
  }
  if (n < 0) _error("ERROR reading header from connection");

  if(msg->header.len>0) {
    n = _ldcs_read_pipe(fdlist_pipe[fd].in_fd,msg->data,msg->header.len, LDCS_READ_BLOCK);
    if (n == 0) 
       return(rc);
    if (n < 0) {
       int error = errno;
       err_printf("Error during read of pipe: %s (%d)\n", strerror(error), error);
       return -1;
    }
    if (n != msg->header.len) {
       int error = errno;
       err_printf("Partial read on pipe.  Got %u / %u: %s (%d)\n",
                  (unsigned) n, (unsigned) msg->header.len,
                  strerror(error), error);
       return -1;
    }

  } else {
    *msg->data = '\0';
  }

  debug_printf3("received message of type: %s len=%d data=%s ...\n",
	       _message_type_to_str(msg->header.type),
	       msg->header.len, msg->data );

  return(rc);
}
Exemple #17
0
int get_stat_result(int fd, const char *path, int is_lstat, int *exists, struct stat *buf)
{
   int result;
   char buffer[MAX_PATH_LEN+1];
   char cache_name[MAX_PATH_LEN+3];
   char *newpath;
   int use_cache = (opts & OPT_SHMCACHE) && (shm_cachesize > 0);
   int found_file = 0;

   if (use_cache) {
      debug_printf2("Looking up %sstat for %s in shared cache\n", is_lstat ? "l" : "", path);
      get_cache_name(path, is_lstat ? "**" : "*", cache_name);
      cache_name[sizeof(cache_name)-1] = '\0';
      found_file = fetch_from_cache(cache_name, &newpath);
   }

   if (!found_file) {
      result = send_stat_request(fd, (char *) path, is_lstat, buffer);
      if (result == -1) {
         *exists = 0;
         return -1;
      }
      newpath = buffer[0] != '\0' ? buffer : NULL;

      if (use_cache) 
         shmcache_update(cache_name, newpath);
   }
   
   if (newpath == NULL) {
      *exists = 0;
      return 0;
   }
   *exists = 1;

   test_log(newpath);
   result = read_stat(newpath, buf);
   if (result == -1) {
      err_printf("Failed to read stat info for %s from %s\n", path, newpath);
      *exists = 0;
      return -1;
   }
   return 0;
}
Exemple #18
0
ssize_t
fd_read_ignoreEOF(int d, void *buf, size_t nbytes)
{
	ssize_t left;
	ssize_t io_ret;
	char *s = (char*)buf;

	for (left = nbytes; left > 0; left -= io_ret){
		fd_can_read_blocked(d);
		io_ret = read(d, s, left);
		if (io_ret <= 0 || exit_req == 1){
			if (io_ret == 0){
				debug_printf2("PIPE_EOF_EOF\n");
			}
			return PIPE_ERROR;
		}
		s += io_ret;
	}
	return nbytes;
}
Exemple #19
0
static int execle_wrapper(const char *path, const char *arg0, ...)
{
   int error, result;
   char **envp;
   char newpath[MAX_PATH_LEN+1];

   VARARG_TO_ARGV;

   envp = va_arg(arglist, char **);
   debug_printf2("Intercepted execle on %s\n", path);
   find_exec(path, argv, newpath, MAX_PATH_LEN+1, &new_argv);
   debug_printf("execle redirection of %s to %s\n", path, newpath);
   result = execve(newpath, new_argv ? new_argv : argv, envp);
   error = errno;

   VARARG_TO_ARGV_CLEANUP;

   set_errno(error);
   return result;
}
Exemple #20
0
static int find_exec(const char *filepath, char **argv, char *newpath, int newpath_size, char ***new_argv)
{
   char *newname = NULL;

   if (!filepath) {
      newpath[0] = '\0';
      return 0;
   }

   check_for_fork();
   if (ldcsid < 0 || !use_ldcs || exec_filter(filepath) != REDIRECT) {
      strncpy(newpath, filepath, newpath_size);
      newpath[newpath_size-1] = '\0';
      return 0;
   }

   sync_cwd();
   debug_printf2("Exec operation requesting file: %s\n", filepath);
   send_file_query(ldcsid, (char *) filepath, &newname);
   debug_printf("Exec file request returned %s -> %s\n", filepath, newname ? newname : "NULL");

   return prep_exec(filepath, argv, newname, newpath, newpath_size, new_argv);
}
Exemple #21
0
static int fetch_from_cache(const char *name, char **newname)
{
   int result;
   char *result_name;
   result = shmcache_lookup_or_add(name, &result_name);
   if (result == -1)
      return 0;

   debug_printf2("Shared cache has mapping from %s (%p) to %s (%p)\n", name, name,
                 (result_name == in_progress) ? "[IN PROGRESS]" :
                 (result_name ? result_name : "[NOT PRESENT]"),
                 result_name);
   if (result_name == in_progress) {
      debug_printf("Waiting for update to %s\n", name);
      result = shmcache_waitfor_update(name, &result_name);
      if (result == -1) {
         debug_printf("Entry for %s deleted while waiting for update\n", name);
         return 0;
      }
   }
   
   *newname = result_name ? spindle_strdup(result_name) : NULL;
   return 1;
}
Exemple #22
0
void debug_assert_fail(const char *module, const int mlen, const char *function, const int flen, const char *file, int line, const char *expr)
{
	debug_printf2(0, module, mlen, function, flen, 1, "%s:%d assertion failed:%s\n", file, line, expr);
	abort();
}