libutil/File.cc

   1 #include <unistd.h>
   2 #include <stdio.h>
   3 #include <fcntl.h>
   4 #include <errno.h>
   5 #include <libgen.h>
   6
   7 #include "libutil/File.h"
   8 #include "libutil/Log.h"
   9
  10 namespace remote { namespace util {
  11
  12 std::string File::readFile(std::string filename)
  13 {
  14         char buffer[1024];
  15         ssize_t size, i;
  16         int fd;
  17
  18         fd = open(filename.c_str(), O_RDONLY | O_NONBLOCK);
  19         if (fd < 0) {
  20                 Log::error("open(%s) failed: %s", filename.c_str(), strerror(errno));
  21                 return std::string("");
  22         }
  23
  24         do {
  25                 size = read(fd, buffer, sizeof(buffer) - 1);
  26         } while ((size < 0) && (errno == EAGAIN || errno == EINTR));
  27
  28         if (size == -1) {
  29                 Log::error("read(%s) failed: %s", filename.c_str(), strerror(errno));
  30                 size = 0;
  31         }
  32
  33         /* Non-blocking, so we should have the full contents now. */
  34         close(fd);
  35
  36         /* Sanitize the string to only hold sane ASCII characters. */
  37         for (i = size - 1; i >= 0; i--) {
  38                 int c = buffer[i];
  39
  40                 if (c <= ' ' || c > 126) {
  41                         /* Discard cruft at the end. */
  42                         if (i + 1 == size) {
  43                                 size--;
  44                                 continue;
  45                         }
  46
  47                         c = '_';
  48                 } else if (c == '\'' || c == '"' || c == '\\') {
  49                         c = '_';
  50                 }
  51
  52                 buffer[i] = c;
  53         }
  54         buffer[size] = 0;
  55
  56         return std::string(buffer);
  57 }
  58
  59 std::string File::readLink(std::string linkname)
  60 {
  61         std::string filename;
  62         char buf[PATH_MAX];
  63         ssize_t buflen;
  64         int relative = 0;
  65
  66         buflen = readlink(linkname.c_str(), buf, sizeof(buf));
  67         if (buflen == -1) {
  68                 Log::error("readlink(%s) failed: %s", linkname.c_str(), strerror(errno));
  69                 return std::string("");
  70         }
  71
  72         buf[buflen] = 0;
  73         filename = buf;
  74
  75         while (filename.substr(0, 3) == "../") {
  76                 filename.erase(0, 3);
  77                 relative++;
  78         }
  79
  80         if (!relative)
  81                 return filename;
  82
  83         if (linkname.size() >= sizeof(buf)) {
  84                 Log::error("Link name too long: %s", linkname.c_str());
  85                 return std::string("");
  86         }
  87
  88         linkname.copy(buf, linkname.size());
  89         do
  90                 dirname(buf);
  91         while (relative--);
  92
  93         filename.insert(0, "/");
  94         filename.insert(0, buf);
  95
  96         return filename;
  97 }
  98
  99 bool File::writeFile(std::string filename, const void *data, uint32_t datalen)
 100 {
 101         ssize_t filesize;
 102         int fd = open(filename.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0644);
 103
 104         if (fd < 0) {
 105                 Log::error("open(%s) failed: %s", filename.c_str(), strerror(errno));
 106                 return false;
 107         }
 108
 109         filesize = write(fd, data, datalen);
 110         if (fd < 0)
 111                 Log::error("write(%s) failed: %s", filename.c_str(), strerror(errno));
 112
 113         close(fd);
 114         if (filesize == (ssize_t) datalen)
 115                 return true;
 116
 117         remove(filename.c_str());
 118         return false;
 119 }
 120
 121 bool File::exists(std::string filename)
 122 {
 123         struct stat buf;
 124
 125         return stat(filename.c_str(), &buf) >= 0;
 126 }
 127
 128 }}