git.mutantstargoat.com Git - vrfileman/blob - src/fspath.cc

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <assert.h>
   4 #include <unistd.h>
   5 #include <sys/stat.h>
   6 #include "fspath.h"
   7
   8
   9 char *make_abs_path(const char *s)
  10 {
  11         char wd[1024];
  12         int slen = s ? strlen(s) : 0;
  13         int len = slen;
  14         char *res;
  15
  16         if(!s || *s != '/') {
  17                 getcwd(wd, sizeof wd);
  18                 int wdlen = strlen(wd);
  19                 len = wdlen + 1 + slen;
  20
  21                 res = new char[len + 1];
  22                 if(s) {
  23                         sprintf(res, "%s/%s", wd, s);
  24                 } else {
  25                         memcpy(res, wd, len + 1);
  26                 }
  27         } else {
  28                 res = new char[len + 1];
  29                 memcpy(res, s, len + 1);
  30         }
  31
  32         return res;
  33 }
  34
  35 FSPath::FSPath()
  36 {
  37         abs_path = name = suffix = parent = 0;
  38 }
  39
  40 FSPath::FSPath(const char *s)
  41 {
  42         abs_path = name = suffix = parent = 0;
  43         set_path(s);
  44 }
  45
  46 FSPath::~FSPath()
  47 {
  48         delete [] abs_path;
  49         delete [] parent;
  50 }
  51
  52 FSPath::FSPath(const FSPath &p)
  53 {
  54         abs_path = name = suffix = parent = 0;
  55
  56         if(abs_path) {
  57                 int len = strlen(p.abs_path);
  58                 abs_path = new char[len + 1];
  59                 memcpy(abs_path, p.abs_path, len + 1);
  60
  61                 if(p.name) {
  62                         name = abs_path + (p.name - p.abs_path);
  63                 }
  64                 if(p.suffix) {
  65                         suffix = abs_path + (p.suffix - p.abs_path);
  66                 }
  67         }
  68         if(p.parent) {
  69                 int len = strlen(p.parent);
  70                 parent = new char[len + 1];
  71                 memcpy(parent, p.parent, len + 1);
  72         }
  73 }
  74
  75 FSPath &FSPath::operator =(const FSPath &p)
  76 {
  77         if(&p != this) {
  78                 delete [] abs_path;
  79                 delete [] parent;
  80                 abs_path = name = suffix = parent = 0;
  81
  82                 if(p.abs_path) {
  83                         int len = strlen(p.abs_path);
  84                         abs_path = new char[len + 1];
  85                         memcpy(abs_path, p.abs_path, len + 1);
  86
  87                         if(p.name) {
  88                                 name = abs_path + (p.name - p.abs_path);
  89                         }
  90                         if(p.suffix) {
  91                                 suffix = abs_path + (p.suffix - p.abs_path);
  92                         }
  93                 }
  94                 if(p.parent) {
  95                         int len = strlen(p.parent);
  96                         parent = new char[len + 1];
  97                         memcpy(parent, p.parent, len + 1);
  98                 }
  99         }
 100         return *this;
 101 }
 102
 103 FSPath::FSPath(FSPath &&p)
 104 {
 105         abs_path = p.abs_path;
 106         name = p.name;
 107         suffix = p.suffix;
 108         parent = p.parent;
 109
 110         p.abs_path = p.name = p.suffix = p.parent = 0;
 111 }
 112
 113 FSPath &FSPath::operator =(FSPath &&p)
 114 {
 115         if(&p != this) {
 116                 delete [] abs_path;
 117                 delete [] parent;
 118
 119                 abs_path = p.abs_path;
 120                 name = p.name;
 121                 suffix = p.suffix;
 122                 parent = p.parent;
 123
 124                 p.abs_path = p.name = p.suffix = p.parent = 0;
 125         }
 126         return *this;
 127 }
 128
 129 void FSPath::sanitize()
 130 {
 131         printf("sanitize: \"%s\"\n", abs_path);
 132
 133         // first pass, convert and backslashes to slashes
 134         char *s = abs_path;
 135         while(*s) {
 136                 if(*s == '\\') {
 137                         *s = '/';
 138                 }
 139                 ++s;
 140         }
 141
 142         // second pass, remove any "./" and "foo/.." parts
 143         s = abs_path;
 144         int len = strlen(s);
 145         while((s = strstr(s, "./"))) {
 146                 len -= 2;
 147                 memmove(s, s + 2, len + 1);
 148         }
 149         assert(len == (int)strlen(abs_path));
 150
 151         s = abs_path;
 152         while((s = strstr(s, "/.."))) {
 153                 char *start = s;
 154                 while(start > abs_path && *--start != '/');
 155
 156                 memmove(start, s + 3, len - 2);
 157                 len -= (s + 3) - start;
 158                 s = start;
 159         }
 160         assert(len == (int)strlen(abs_path));
 161
 162         // remove double slashes
 163         while((s = strstr(abs_path, "//"))) {
 164                 memmove(s, s + 1, len-- - (s - abs_path));
 165         }
 166         assert(len == (int)strlen(abs_path));
 167
 168         // remove trailing slash if abs_path is not just a slash (root)
 169         if(len > 1 && abs_path[len - 1] == '/') {
 170                 abs_path[--len] = 0;
 171         }
 172         assert(len == (int)strlen(abs_path));
 173
 174         // setup name and prefix pointers as necessary
 175         name = suffix = 0;
 176         s = abs_path;
 177         while(*s) {
 178                 if(*s == '/') name = s + 1;
 179                 if(*s == '.') suffix = s;
 180                 ++s;
 181         }
 182
 183         if(!name) {
 184                 name = abs_path;        // shouldn't happen, all paths start with a slash
 185                 fprintf(stderr, "FSPath::sanitize: absolute path \"%s\" isn't absolute!\n", abs_path);
 186         }
 187
 188         if(suffix == abs_path || suffix <= name) {
 189                 suffix = 0;
 190         }
 191
 192         // create parent name string
 193         if(abs_path[0] == '/' && abs_path[1] == 0) {
 194                 parent = 0;     // root dir has no parent
 195         } else {
 196                 int plen = name - 1 - abs_path;
 197                 assert(plen >= 0);
 198
 199                 if(plen == 0) {
 200                         plen = 1;       // our parent is root, so we need the slash
 201                 }
 202
 203                 parent = new char[plen + 1];
 204                 memcpy(parent, abs_path, plen);
 205                 parent[plen] = 0;
 206         }
 207 }
 208
 209 bool FSPath::set_path(const char *s)
 210 {
 211         char *tmp = make_abs_path(s);
 212         if(!tmp) {
 213                 return false;
 214         }
 215
 216         delete [] abs_path;
 217         delete [] parent;
 218         abs_path = tmp;
 219         parent = 0;
 220
 221         sanitize();
 222         return true;
 223 }
 224
 225 const char *FSPath::get_path() const
 226 {
 227         return abs_path;
 228 }
 229
 230 const char *FSPath::get_name() const
 231 {
 232         return name;
 233 }
 234
 235 const char *FSPath::get_suffix() const
 236 {
 237         return suffix;
 238 }
 239
 240 const char *FSPath::get_parent() const
 241 {
 242         return parent;
 243 }
 244
 245 bool FSPath::append_path(const char *s)
 246 {
 247         if(!s || !*s) return false;
 248
 249         if(!abs_path) {
 250                 return set_path(s);
 251         }
 252
 253         if(*s == '/') {
 254                 return false;   // can't append an absolute path
 255         }
 256
 257         int len = strlen(abs_path) + 1 + strlen(s);
 258         try {
 259                 char *tmp = new char[len + 1];
 260
 261                 delete [] abs_path;
 262                 abs_path = tmp;
 263                 delete [] parent;
 264                 parent = 0;
 265         }
 266         catch(...) {
 267                 return false;
 268         }
 269
 270         sanitize();
 271         return true;
 272 }
 273
 274 bool FSPath::exists() const
 275 {
 276         struct stat st;
 277         return abs_path && stat(abs_path, &st) != -1;
 278 }
 279
 280 bool FSPath::is_file() const
 281 {
 282         struct stat st;
 283         return abs_path && stat(abs_path, &st) != -1 && S_ISREG(st.st_mode);
 284 }
 285
 286 bool FSPath::is_dir() const
 287 {
 288         struct stat st;
 289         return abs_path && stat(abs_path, &st) != -1 && S_ISDIR(st.st_mode);
 290 }
 291
 292 bool FSPath::is_dev() const
 293 {
 294         struct stat st;
 295         unsigned int devmask = S_IFBLK | S_IFCHR;
 296         return abs_path && stat(abs_path, &st) != -1 && (st.st_mode & devmask);
 297 }
 298
 299 FSPath::operator const char* () const
 300 {
 301         return abs_path;
 302 }