release/src/router/shared/files.c

   1 /*
   2
   3         Tomato Firmware
   4         Copyright (C) 2006-2009 Jonathan Zarate
   5
   6 */
   7
   8 #include <string.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <fcntl.h>
  13 #include <sys/stat.h>
  14 #include <stdarg.h>
  15
  16 #include <bcmnvram.h>
  17 #include "shutils.h"
  18 #include "shared.h"
  19
  20
  21 int f_exists(const char *path)  // note: anything but a directory
  22 {
  23         struct stat st;
  24         return (stat(path, &st) == 0) && (!S_ISDIR(st.st_mode));
  25 }
  26
  27 unsigned long f_size(const char *path)  // 4GB-1        -1 = error
  28 {
  29         struct stat st;
  30         if (stat(path, &st) == 0) return st.st_size;
  31         return (unsigned long)-1;
  32 }
  33
  34 int f_read(const char *path, void *buffer, int max)
  35 {
  36         int f;
  37         int n;
  38
  39         if ((f = open(path, O_RDONLY)) < 0) return -1;
  40         n = read(f, buffer, max);
  41         close(f);
  42         return n;
  43 }
  44
  45 int f_write(const char *path, const void *buffer, int len, unsigned flags, unsigned cmode)
  46 {
  47         static const char nl = '\n';
  48         int f;
  49         int r = -1;
  50         mode_t m;
  51
  52         m = umask(0);
  53         if (cmode == 0) cmode = 0666;
  54         if ((f = open(path, (flags & FW_APPEND) ? (O_WRONLY|O_CREAT|O_APPEND) : (O_WRONLY|O_CREAT|O_TRUNC), cmode)) >= 0) {
  55                 if ((buffer == NULL) || ((r = write(f, buffer, len)) == len)) {
  56                         if (flags & FW_NEWLINE) {
  57                                 if (write(f, &nl, 1) == 1) ++r;
  58                         }
  59                 }
  60                 close(f);
  61         }
  62         umask(m);
  63         return r;
  64 }
  65
  66 int f_read_string(const char *path, char *buffer, int max)
  67 {
  68         if (max <= 0) return -1;
  69         int n = f_read(path, buffer, max - 1);
  70         buffer[(n > 0) ? n : 0] = 0;
  71         return n;
  72 }
  73
  74 int f_write_string(const char *path, const char *buffer, unsigned flags, unsigned cmode)
  75 {
  76         return f_write(path, buffer, strlen(buffer), flags, cmode);
  77 }
  78
  79 static int _f_read_alloc(const char *path, char **buffer, int max, int z)
  80 {
  81         unsigned long n;
  82
  83         *buffer = NULL;
  84         if (max >= 0) {
  85                 if ((n = f_size(path)) != (unsigned long)-1) {
  86                         if (n < max) max = n;
  87                         if ((!z) && (max == 0)) return 0;
  88                         if ((*buffer = malloc(max + z)) != NULL) {
  89                                 if ((max = f_read(path, *buffer, max)) >= 0) {
  90                                         if (z) *(*buffer + max) = 0;
  91                                         return max;
  92                                 }
  93                                 free(buffer);
  94                         }
  95                 }
  96         }
  97         return -1;
  98 }
  99
 100 int f_read_alloc(const char *path, char **buffer, int max)
 101 {
 102         return _f_read_alloc(path, buffer, max, 0);
 103 }
 104
 105 int f_read_alloc_string(const char *path, char **buffer, int max)
 106 {
 107         return _f_read_alloc(path, buffer, max, 1);
 108 }
 109
 110
 111 static int _f_wait_exists(const char *name, int max, int invert)
 112 {
 113         while (max-- > 0) {
 114                 if (f_exists(name) ^ invert) return 1;
 115                 sleep(1);
 116         }
 117         return 0;
 118 }
 119
 120 int f_wait_exists(const char *name, int max)
 121 {
 122         return _f_wait_exists(name, max, 0);
 123 }
 124
 125 int f_wait_notexists(const char *name, int max)
 126 {
 127         return _f_wait_exists(name, max, 1);
 128 }