Community Company Search Contact

filemover_util.c from EmStar at Krugle

Show filemover_util.c syntax highlighted

char filemover_util_c_cvsid[] = "$Id: filemover_util.c,v 1.3 2006/04/20 02:22:11 mlukac Exp $";


#include <libmisc/misc.h>
#include <devel/dts/dts_shared.h>





void usage() {
  elog(LOG_WARNING, "./fmu -f filename [-s]");
  elog(LOG_WARNING, "\t -s splits the meta from the file");
}


void split_meta(char *file, int quiet) {

  char metafile[4096] = {};
  char datafile[4096] = {};
  
  /* remove the .dts */ 
  if (strstr(file, ".dts") == NULL) {
    strcpy(datafile, file);
  } else {
    int size = strstr(file, ".dts") - file;
    strncpy(datafile, file, size);
  }
  sprintf(metafile, "%s.meta", datafile);

  /* create an open the files */
  int mfd = open(metafile, O_RDWR | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
  if (mfd <= 0) {
    elog(LOG_WARNING, "Error creating %s: %s", metafile, strerror(errno));
    return;
  }
  int dfd = open(datafile, O_RDWR | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
  if (dfd <= 0) {
    elog(LOG_WARNING, "Error creating %s: %s", datafile, strerror(errno));
    close (mfd);
    return;
  }
  int ffd = open(file, O_RDONLY);
  if (ffd <= 0) {
    elog(LOG_WARNING, "Error opening %s: %s", file, strerror(errno));
    close (mfd);
    close (dfd);
    return;
  }
  struct stat s = {};
  fstat(ffd, &s);

  /* read the header */
  filemover_meta_header_t fmht = {};
  int res = read(ffd, (void *) &fmht, sizeof(filemover_meta_header_t));
  if (res < sizeof(filemover_meta_header_t)) {
    elog(LOG_WARNING, "Short read on header for %s: %s", file, strerror(errno));
    close (mfd);
    close (dfd);
    close (ffd);
    return;
  }
  
  int hsize = (fmht.filemover_meta_version == FILEMOVER_META_VERSION1) ? 
    FILEMOVER_META_VERSION1_SIZE : 2048;
  int teles = (hsize - sizeof(filemover_meta_header_t)) / 
    sizeof(filemover_meta_entry_t);

  if (fmht.filemover_meta_version == FILEMOVER_META_VERSION1) {
    if (fmht.filemover_meta_size != FILEMOVER_META_VERSION1_SIZE) {
      elog(LOG_WARNING, "Inavlid meta size for version 1!");
      close (mfd);
      close (dfd);
      close (ffd);
      return;
    }   
  } else if (fmht.filemover_meta_version == FILEMOVER_META_VERSION2) {
    /*
      if (fmht.filemover_meta_size != FILEMOVER_META_VERSION2_SIZE) {
      elog(LOG_WARNING, "Inavlid meta size for version 2!");
      close (mfd);
      close (dfd);
      close (ffd);
      return;
      }
    */
  } else {
    elog(LOG_WARNING, "Unknown version!");
    close (mfd);
    close (dfd);
    close (ffd);
    return;
  }
  
  if (!quiet) {
    buf_t *buf = buf_new();
    bufprintf(buf, "\n*** File %s ***", file);
    bufprintf(buf, "Meta-Meta Info: Version %i: %s (%i)\n",
	      fmht.filemover_meta_version,
	      fmht.filemover_meta_version_string, fmht.filemover_meta_size);
    bufprintf(buf, "                %i of %i slots used\n",
	      fmht.filemover_num_elements, teles);
    bufprintf(buf, "               reported size: %lld actual size: %ld -- %s\n",
	      fmht.file_size, s.st_size - fmht.filemover_meta_size, 
	      (fmht.file_size == s.st_size - fmht.filemover_meta_size) ? 
	      "Match!" : "No Match! Error!");
    bufprintf(buf, "\n");
    elog(LOG_WARNING, "%s", buf_get(buf));
    buf_free(buf);
  }


  if (lseek(ffd, 0, SEEK_SET) < 0) {
    elog(LOG_WARNING, "Error setting seek to 0 on %s: %s", file, strerror(errno));
    close (mfd);
    close (dfd);
    close (ffd);
    return;
  }

  char metabuf[fmht.filemover_meta_size];
  memset(metabuf, 0, fmht.filemover_meta_size);
  res = read(ffd, metabuf, fmht.filemover_meta_size);
  if (res < fmht.filemover_meta_size) {
    elog(LOG_WARNING, "Incomplete read of meta in %s: %i of %i: %s", file, res, fmht.filemover_meta_size, strerror(errno));
    close (mfd);
    close (dfd);
    close (ffd);
    return;    
  }

  int numeles = fmht.filemover_num_elements;
  if (!quiet) {
    filemover_meta_entry_t *fme;
    char *temp;
    temp = metabuf + sizeof(filemover_meta_header_t);
    fme = (filemover_meta_entry_t *) temp;
    buf_t *buf = buf_new();
    bufprintf(buf, "\n");
    int i = 0;
    for (i = 0; i < numeles; ++i) {
      bufprintf(buf, "*** %i of %i ***\n", i + 1, numeles);
      bufprintf(buf, "\t From %i:%s -- To %i:%s\n", 
		fme[i].stats.from_node, print_if_id(fme[i].stats.from_ip),
		fme[i].stats.to_node, print_if_id(fme[i].stats.to_ip));
      
      bufprintf(buf, "\t Total time: %ld -- Total xfer time %ld -- retries %i\n",
		fme[i].stats.total_time_beforesend,
		fme[i].stats.total_xfer_time, fme[i].stats.retries);
      bufprintf(buf, "\t Bandwidth %f -- Diskspace at time %ld\n\n",
		fme[i].stats.bandwidth, fme[i].stats.diskspace);
    }
    int valid = 1;
    for (i = numeles; i < teles; ++i) {
      if (fme[i].stats.from_node != 0 || fme[i].stats.to_node != 0) {
	valid = 0;
      }
    }
    
    if (valid) {
      bufprintf(buf, "*** Remainder of header is clean!!!\n");
    } else {
      bufprintf(buf, "*** Found some extra junk after meta elements!!!\n");
    }
    buf_free(buf);
  }
  /* write everything out */
  
  res = write(mfd, metabuf, fmht.filemover_meta_size);
  if (res < fmht.filemover_meta_size) {
    elog(LOG_WARNING, "Got short write on %s, %i of %i: %s", metafile, res,
	 fmht.filemover_meta_size, strerror(errno));
    close (mfd);
    close (dfd);
    close (ffd);
    return;    
  }
  close(mfd);

  char readbuf[4096];
  while ((res = read(ffd, readbuf, 4096)) > 0) {
    if (write(dfd, readbuf, res) < res) {
      elog(LOG_WARNING, "Got short write %s: only %i: %s", datafile, res, strerror(errno));
      close (dfd);
      close (ffd);
      return;    
    }
  }
  if (res < 0) {
    elog(LOG_WARNING, "Error reading from file %s: %s", file, strerror(errno));
    close (dfd);
    close (ffd);
    return;    
  }
  close (dfd);
  close (ffd);

}


void print_meta(char *file, int shortout) {

  int fd = open(file, O_RDONLY);
  if (fd <= 0) {
    elog(LOG_WARNING, "%s: %s", file, strerror(errno));
    return;
  }
  
  node_id_t fullpath[256] = {};
  int pathindex = 0;
  uint64_t size = 0;

  struct stat s = {};
  fstat(fd, &s);


  filemover_meta_header_t fmht = {};

  int res = read(fd, &fmht, sizeof(filemover_meta_header_t));
  if (res <= 0) {
    elog(LOG_WARNING, "Bad read: %s: %s", file, strerror(errno));
    close(fd);
    return;
  }

  buf_t *buf = buf_new();
  if (!shortout) {
    bufprintf(buf, "\n\n***** %s *****\n", file);
    bufprintf(buf, "Meta-Meta Info: Version %i: %s (%i)\n", fmht.filemover_meta_version,
	      fmht.filemover_meta_version_string, fmht.filemover_meta_size);
  } else {
	bufprintf(buf, "# %s\n", file);
  }

  int hsize = (fmht.filemover_meta_version == FILEMOVER_META_VERSION1) ? FILEMOVER_META_VERSION1_SIZE : 2048;
  int teles = (hsize - sizeof(filemover_meta_header_t)) / sizeof(filemover_meta_entry_t);

  if (!shortout) {
    bufprintf(buf, "                %i of %i slots used\n", fmht.filemover_num_elements, teles);
    bufprintf(buf, "               reported size: %lld actual size: %ld -- %s\n",
	      fmht.file_size, s.st_size - fmht.filemover_meta_size, (fmht.file_size == s.st_size - fmht.filemover_meta_size) ? "Match!" : "No Match! Error!");

    bufprintf(buf, "\n");
  }

  size = fmht.file_size;

  int numeles = fmht.filemover_num_elements;
  filemover_meta_entry_t fme[teles];
  
  //  lseek(fd, sizeof(filemover_meta_header_t), SEEK_SET);
  res = read(fd, (void *) fme, sizeof(filemover_meta_entry_t) * teles);
  if (res < sizeof(filemover_meta_entry_t) * teles) {
    elog(LOG_WARNING, "Incomplete read: %s: %i of %i: %s", file, res,
	 sizeof(filemover_meta_entry_t) * teles, strerror(errno));
    buf_free(buf);
    close(fd);
  }

  int i = 0;
  for (i = 0; i < numeles; ++i) {
    if (!shortout) {
      bufprintf(buf, "*** %i of %i ***\n", i + 1, numeles);
      bufprintf(buf, "\t From %i:%s -- To %i:%s\n", 
		fme[i].stats.from_node, print_if_id(fme[i].stats.from_ip),
		fme[i].stats.to_node, print_if_id(fme[i].stats.to_ip));
      
      bufprintf(buf, "\t Total time: %ld -- Total xfer time %ld -- retries %i\n",
		fme[i].stats.total_time_beforesend, fme[i].stats.total_xfer_time, fme[i].stats.retries);
      bufprintf(buf, "\t Bandwidth %f -- Diskspace at time %ld\n\n",
		fme[i].stats.bandwidth, fme[i].stats.diskspace);
    } else {
      bufprintf(buf, "HOP: %lld %i %i %ld %ld %i %f %ld\n",
		size,
		fme[i].stats.from_node, fme[i].stats.to_node,
		fme[i].stats.total_time_beforesend, fme[i].stats.total_xfer_time,
		fme[i].stats.retries,
		fme[i].stats.bandwidth, fme[i].stats.diskspace);
      if (i == 0) {
	fullpath[pathindex] = fme[i].stats.from_node;
	pathindex += 1;
      }
      fullpath[pathindex] = fme[i].stats.to_node;
      pathindex += 1;
    }
  }
  
  if (shortout) {
    bufprintf(buf, "PATH:");
    for (i = 0; i < pathindex; ++i) {
      bufprintf(buf, " %i", fullpath[i]);
    }
    bufprintf(buf, "\n");
  }

  int valid = 1;
  for (i = numeles; i < teles; ++i) {
    if (fme[i].stats.from_node != 0 || fme[i].stats.to_node != 0) {
      valid = 0;
    }
  }

  if (!shortout) {
    if (valid) {
      bufprintf(buf, "*** Remainder of header is clean!!!\n");
    } else {
      bufprintf(buf, "*** Found some extra junk after meta elements!!!\n");
    }
    bufprintf(buf, "\n");
  }

  if (shortout) 
    printf("%s", buf_get(buf));
  else
    printf("\n%s", buf_get(buf));

  buf_free(buf);
  close(fd);

}


int main(int argc, char **argv) {


  char *file = misc_parse_out_option(&argc, argv, "file", 'f');
  int split = misc_parse_out_switch(&argc, argv, "split", 's');
  int force = misc_parse_out_switch(&argc, argv, "force", 'x');
  int quiet = misc_parse_out_switch(&argc, argv, "quiet", 'q');
  int shortout = misc_parse_out_switch(&argc, argv, "short", 0);

  if (file == NULL) {
    usage();
    return 1;
  }

  if (strcmp(file, "") == 0) {
    usage();
    return 1;
  }

  if (!filemover_meta_check_meta(file)) {
    if (!quiet)
      elog(LOG_WARNING, "Does not appear to have meta information!");
    if (!force) {
      if (!quiet)
	elog(LOG_WARNING, "Add -x to force read");
      return 1;
    } else {
      if (!quiet)
	elog(LOG_WARNING, "Continuing as requested");
    }
  }
  
  if (split) {
    split_meta(file, quiet);
  } else {
   print_meta(file, shortout);
  }

  return 0;

}

See more files for this project here

EmStar

EmStar is a software system for developing and deploying wireless sensor networks involving Linux-based platforms. As the wireless sensor network community has attempted to deploy more complex designs---large-scale, long-lived systems that need self-organization and adaptivity---a number of difficult software design issues have arisen. Advances in software design have not kept pace with the capabilities of hardware. This is because designing for an adaptive, efficient, and useful sensor network has turned out to be surprisingly complex and difficult. EmStar is a Linux-based software framework, whose goal is to dramatically reduce this complexity, enabling work to be shared and reused, and simplifying and speeding the design of new sensor network applications.

Project homepage: http://cvs.cens.ucla.edu/emstar/
Programming language(s): C,Shell Script
License: other

  filemover_dlist_reader.c
  filemover_util.c