Community Company Search Contact

filemover_meta.c from EmStar at Krugle

Show filemover_meta.c syntax highlighted

#include <devel/dts/dts_shared.h>


char filemover_meta_c_cvsid[] = "$Id: filemover_meta.c,v 1.2 2006/04/20 02:05:38 mlukac Exp $";



int filemover_meta_check_meta(char *file)
{

  if (strstr(file, ".dts") == NULL)
    return 0;

  int fd = open(file, O_RDONLY);
  if (fd <= 0) {
    elog(LOG_WARNING, "Error opening %s to check for metadata: %s", file, strerror(errno));
    return 0;
  }

  filemover_meta_header_t fmht = {};

  int res = read(fd, (char *) &fmht, sizeof(filemover_meta_header_t));
  if (res < sizeof(filemover_meta_header_t)) {
    elog(LOG_WARNING, "Error reading %i bytes from %s, only read %i: %s",
	 sizeof(filemover_meta_header_t), file, res, strerror(errno));
    close(fd);
    return 0;
  }
  close(fd);

  if ((fmht.filemover_meta_version == FILEMOVER_META_VERSION1 ||
       fmht.filemover_meta_version == FILEMOVER_META_VERSION2) &&
      (strcmp(fmht.filemover_meta_version_string, FILEMOVER_META_VERSION1_STRING) == 0 ||
       strcmp(fmht.filemover_meta_version_string, FILEMOVER_META_VERSION2_STRING) == 0)
      ) {
    
    //    elog(LOG_WARNING, "Found file with meta versoin %i: %s:",
    //	 (fmht.filemover_meta_version == FILEMOVER_META_VERSION1) ? 1 : 2,
    //	 file);

    close(fd);
    return 1;
  }
      
  close(fd);
  return 0;
}

/* converts file to a .dts file in place */

int filemover_meta_initialize_meta(char *file)
{

  unsigned char fileheader[FILEMOVER_META_VERSION1_SIZE] = {};
  char newfile[strlen(file) + 5];

  if (filemover_meta_check_meta(file)) {
    elog(LOG_WARNING, "File already has meta data");
    return 1;
  }
  
  struct stat s = {};
  if (stat(file, &s) < 0) {
    elog(LOG_WARNING, "Unable to stat %s pre meta: %s", file, strerror(errno));
    return 1;
  }

  filemover_meta_header_t fmht = {
    filemover_meta_version: FILEMOVER_META_VERSION1,
    filemover_meta_size: FILEMOVER_META_VERSION1_SIZE,
    filemover_num_elements: 0,
  };
  fmht.file_size = s.st_size;
  strncpy(fmht.filemover_meta_version_string, FILEMOVER_META_VERSION1_STRING, 
	  FILEMOVER_META_VERSION_STRING_SIZE);
  
  
  elog(LOG_WARNING, "Can fit %i elements in header. subheader %i element %i",
       (FILEMOVER_META_VERSION1_SIZE - sizeof(filemover_meta_header_t)) / sizeof(filemover_meta_entry_t),
       sizeof(filemover_meta_header_t), sizeof(filemover_meta_entry_t));

  memcpy(fileheader, &fmht, sizeof(fmht));


  sprintf(newfile, "%s.dts", file);

  int infile = open(file, O_RDONLY);
  if (infile <= 0) {
    elog(LOG_WARNING, "Error opening %s for meta: %s", file, strerror(errno));
    return 1;
  }
  elog(LOG_WARNING, "1");
  int outfile = open(newfile, O_RDWR | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
  if (outfile <=0) {
    elog(LOG_WARNING, "Error opening %s for meta: %s", newfile, strerror(errno));
    close(infile);
    unlink(newfile);
    return 1;
  }
  elog(LOG_WARNING, "2");
  
  if (write(outfile, fileheader, FILEMOVER_META_VERSION1_SIZE) < FILEMOVER_META_VERSION1_SIZE) {
    elog(LOG_WARNING, "Error writing meta to file %s: %s", newfile, strerror(errno));
    close(infile);
    close(outfile);
    unlink(newfile);
    return 1;
  }

  char buf[4096] = {};
  int res = 0;
  while ((res = read(infile, buf, 4096)) > 0) {
    if (write(outfile, buf, res) < 0) {
      elog(LOG_WARNING, "Error writing meta to file %s: %s", newfile, strerror(errno));
      close(infile);
      close(outfile);
      unlink(newfile);
      return 1;
    }
    //    elog(LOG_WARNING, "Write %i to file", res);
  }
  elog(LOG_WARNING, "4");

  close(infile);
  close(outfile);

  if (unlink(file) < 0) {
    elog(LOG_WARNING, "Error unlinking %s ", file);
    return 1;
  }

  return 0;
}



int filemover_meta_update_meta(char *file, tcpxfer_done_stats_packet_t *stats)
{
  
  
  if (filemover_meta_check_meta(file) == 0)
    return 0;
  
  /* read in header */
  int fd = open(file, O_RDWR);
  if (fd <= 0) {
    elog(LOG_WARNING, "Error opening file for meta update: %s: %s",
	 file, strerror(errno));
    return 0;
  }
  lseek(fd, 0, SEEK_SET); /* probbaly do notneed this */

  /* read first part */
  filemover_meta_header_t fmht = {};
  int res = read(fd, (void *) &fmht, sizeof(filemover_meta_header_t));
  if (res != sizeof(filemover_meta_header_t)) {
    elog(LOG_WARNING, "couldn't read %i from %s, only read %i: %s",
	 sizeof(filemover_meta_header_t), file, res, strerror(errno));
    close(fd);
    return 0;
  }
  
  elog(LOG_WARNING, "Adding meta to file %s: version %s, header size %i",
       file, fmht.filemover_meta_version_string, fmht.filemover_meta_size);
  elog(LOG_WARNING, "File already has %i meta entries",
       fmht.filemover_num_elements);



  /* read in all the whole header into meta data */
  int totalfit = (fmht.filemover_meta_size - sizeof(filemover_meta_header_t)) /
    sizeof(filemover_meta_entry_t);
  if (fmht.filemover_num_elements >= totalfit) {
    elog(LOG_WARNING, "Meta data header is full: %i of %i", fmht.filemover_num_elements,
	 totalfit);
    close(fd);
    return 0;
  }
  elog(LOG_WARNING, "Meta data header: %i of %i used: %s",
       fmht.filemover_num_elements, totalfit, file);

  filemover_meta_entry_t fme[totalfit];
  res = 0;
  int totalread = 0;
  int totalsize = sizeof(filemover_meta_entry_t) * totalfit;
  while ((res = read(fd, ((void *) fme) + totalread , totalsize - totalread)) 
	 != (totalsize - totalread)) {
    totalread += res;
  }

  /* find the first empty slot */
  for (res = 0; res < totalfit; ++res) {
    if (fme[res].stats.to_node == 0 && fme[res].stats.from_node == 0) {
      elog(LOG_WARNING, "Found empty meta slot at %i of %i: %s", res, totalfit, file);
      break;
    }
  }

  /* copy */
  filemover_meta_entry_t f = {};

  //  memmove(&(fme[res].stats), stats, sizeof(tcpxfer_done_stats_packet_t));
  memmove(&(f.stats), stats, sizeof(tcpxfer_done_stats_packet_t));
  //  elog(LOG_WARNING, "Bandwidth is %f should be %f", fme[res].stats.bandwidth, );
  //  memset(&(f.stats), 1, sizeof(tcpxfer_done_stats_packet_t));
 
  /* update */
  fmht.filemover_num_elements += 1;
  //  memset(&(fmht), 1, sizeof(filemover_meta_header_t));


  /* rewrite */
  if (lseek(fd, 0, SEEK_SET) != 0) {
    elog(LOG_WARNING, "Unable to seek to begining, write meta failed %s: %s",
	 file, strerror(errno));
    close(fd);
    return 0;
  }

  if (write(fd, &fmht, sizeof(filemover_meta_header_t)) != sizeof(filemover_meta_header_t)) {
    elog(LOG_CRIT, "Error writing metadata header! Possibly corrupt! %s: %s", file, strerror(errno));
    close(fd);
    return 0;
  }
 
  if (lseek(fd, sizeof(filemover_meta_header_t) + (sizeof(filemover_meta_entry_t) * res), SEEK_SET) !=
      sizeof(filemover_meta_header_t) + (sizeof(filemover_meta_entry_t) * res)) {
    elog(LOG_WARNING, "Unable to seek to correct spot in header! %s: %s", file, strerror(errno));
    close(fd);
    return 0;
  }

  if (write(fd, &f, sizeof(filemover_meta_entry_t)) != sizeof(filemover_meta_entry_t)) {
    elog(LOG_CRIT, "Error writing metadata! Possibly corrupt! %s: %s", file, strerror(errno));
    close(fd);
    return 0;
  }
 
  close(fd);
  return 1;

}

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_meta.c