/alps/fastwriter

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <string.h>

#include <strings.h>

#include <errno.h>

#define MEMINFO_FILE "/proc/meminfo"

#define MTAB_FILE "/etc/mtab"

#define BAD_OPEN_MESSAGE					\

"Error: /proc must be mounted\n"				\

"  To mount /proc at boot you need an /etc/fstab line like:\n"	\

"      /proc   /proc   proc    defaults\n"			\

"  In the meantime, run \"mount /proc /proc -t proc\"\n"

/* This macro opens filename only if necessary and seeks to 0 so

 * that successive calls to the functions are more efficient.

 * It also reads the current contents of the file into the global buf.

 */

#define FILE_TO_BUF(filename) do{				\

    static int fd, local_n;					\

    if ((fd = open(filename, O_RDONLY)) == -1) {		\

	fputs(BAD_OPEN_MESSAGE, stderr);			\

	fflush(NULL);						\

	return -102;						\

    }								\

    lseek(fd, 0L, SEEK_SET);					\

    if ((local_n = read(fd, buf, sizeof buf - 1)) < 0) {	\

	perror(filename);					\

	fflush(NULL);						\

	return -103;						\

    }								\

    buf[local_n] = '\0';					\

    close(fd);							\

}while(0)

typedef struct mem_table_struct {

  const char *name;     /* memory type name */

  unsigned long *slot; /* slot in return struct */

} mem_table_struct;

static int compare_mem_table_structs(const void *a, const void *b){

  return strcmp(((const mem_table_struct*)a)->name,((const mem_table_struct*)b)->name);

}

size_t fastwriter_get_free_memory(void){

  char buf[4096];

  unsigned long kb_main_buffers, kb_main_cached, kb_main_free;

  char namebuf[16]; /* big enough to hold any row name */

  mem_table_struct findme = { namebuf, NULL};

  mem_table_struct *found;

  char *head;

  char *tail;

  const mem_table_struct mem_table[] = {

    {"Buffers",      &kb_main_buffers}, // important

    {"Cached",       &kb_main_cached},  // important

    {"MemFree",      &kb_main_free},    // important

  };

  const int mem_table_count = sizeof(mem_table)/sizeof(mem_table_struct);

  FILE_TO_BUF(MEMINFO_FILE);

  head = buf;

  for(;;){

    tail = strchr(head, ':');

    if(!tail) break;

    *tail = '\0';

    if(strlen(head) >= sizeof(namebuf)){

      head = tail+1;

      goto nextline;

    }

    strcpy(namebuf,head);

    found = bsearch(&findme, mem_table, mem_table_count,

        sizeof(mem_table_struct), compare_mem_table_structs

    );

    head = tail+1;

    if(!found) goto nextline;

    *(found->slot) = strtoul(head,&tail,10);

nextline:

    tail = strchr(head, '\n');

    if(!tail) break;

    head = tail+1;

  }

  return (kb_main_buffers + kb_main_cached + kb_main_free) * 1024;

}

int fastwriter_get_file_fs(const char *fname, size_t size, char *fs) {

  int err = 0;

  char buf[4096];

  char *fn;

  char *head;

  char *tail;

  size_t len, max = 0;

  struct stat st;

  if ((!fname)||(!fs)||(size < 3)) return EINVAL;

  if (*fname == '/') {

    fn = (char*)fname;

  } else {

    if (!getcwd(buf, 4095)) return errno;

    fn = malloc(strlen(fname) + strlen(buf) + 2);

    if (!fn) return ENOMEM;

    sprintf(fn, "%s/%s", buf, fname);

  }

  if (!stat(fn, &st)) {

    if (!S_ISREG(st.st_mode)) {

	strcpy(fs, "raw");

	goto clean;

    }

  }

  FILE_TO_BUF(MTAB_FILE);

  head = buf;

  for(;;){

    head = strchr(head, ' ');

    if(!head) break;

    head += 1;

    tail = strchr(head, ' ');

    if(!tail) break;

    *tail = '\0';

    len = strlen(head);

    if((len <= max)||(strncmp(head, fn, len))) {

      head = tail+1;

      goto nextline;

    }

    head = tail + 1;

    tail = strchr(head, ' ');

    if(!tail) break;

    *tail = '\0';

    if (!strncasecmp(head,"root",4)) {

	head = tail+1;

	goto nextline;

    }

    max = len;

    if (strlen(head) >= size) err = EFAULT;

    else {

	err = 0;

	strcpy(fs, head);

    }

    head = tail+1;

nextline:

    tail = strchr(head, '\n');

    if(!tail) break;

    head = tail+1;

  }

clean:  

  if (fn != fname) free(fn);

  return err;

}