src/kits/storage/storage_support.cpp

   1 //----------------------------------------------------------------------
   2 //  This software is part of the OpenBeOS distribution and is covered
   3 //  by the MIT License.
   4 //----------------------------------------------------------------------
   5 /*!
   6         \file storage_support.cpp
   7         Implementations of miscellaneous internal Storage Kit support functions.
   8 */
   9
  10 #include <new>
  11 #include <ctype.h>
  12 #include <string.h>
  13
  14 #include <StorageDefs.h>
  15 #include <SupportDefs.h>
  16
  17 #include <syscalls.h>
  18
  19 #include "storage_support.h"
  20
  21 using std::nothrow;
  22
  23 namespace BPrivate {
  24 namespace Storage {
  25
  26 /*!     \param path the path
  27         \return \c true, if \a path is not \c NULL and absolute, \c false otherwise
  28 */
  29 bool
  30 is_absolute_path(const char *path)
  31 {
  32         return (path && path[0] == '/');
  33 }
  34
  35 // parse_path
  36 /*!     \brief Parses the supplied path and returns the position of the leaf name
  37                    part of the path and the length of its directory path part.
  38
  39         The value returned in \a fullPath is guaranteed to be > 0, i.e. the
  40         function always returns a non-empty directory path part. The leaf name
  41         part may be empty though (i.e. \code leafStart == leafEnd \endcode), which
  42         will happen, if the supplied path consists only of one component.
  43
  44         \param fullPath The path to be parsed.
  45         \param dirEnd Reference to a variable into which the end index of the
  46                    directory part shall be written. The index is exclusive.
  47         \param leafStart Reference to a variable into which the start index of
  48                    the leaf name part shall be written. The index is inclusive.
  49         \param leafEnd Reference to a variable into which the end index of
  50                    the leaf name part shall be written. The index is exclusive.
  51         \return \c B_OK, if everything went fine, B_BAD_VALUE, if the supplied
  52                    path is invalid.
  53 */
  54 status_t
  55 parse_path(const char *fullPath, int &dirEnd, int &leafStart, int &leafEnd)
  56 {
  57         // check path and get length
  58         if (!fullPath)
  59                 return B_BAD_VALUE;
  60         int pathLen = strlen(fullPath);
  61         if (pathLen == 0)
  62                 return B_BAD_VALUE;
  63         // find then end of the leaf name (skip trailing '/')
  64         int i = pathLen - 1;
  65         while (i >= 0 && fullPath[i] == '/')
  66                 i--;
  67         leafEnd = i + 1;
  68         if (leafEnd == 0) {
  69                 // fullPath consists of slashes only
  70                 dirEnd = leafStart = leafEnd = 1;
  71                 return B_OK;
  72         }
  73         // find the start of the leaf name
  74         while (i >= 0 && fullPath[i] != '/')
  75                 i--;
  76         leafStart = i + 1;
  77         if (leafStart == 0) {
  78                 // fullPath contains only one component
  79                 dirEnd = leafStart = leafEnd;
  80                 return B_OK;
  81         }
  82         // find the end of the dir path
  83         while (i >= 0 && fullPath[i] == '/')
  84                 i--;
  85         dirEnd = i + 1;
  86         if (dirEnd == 0)        // => fullPath[0] == '/' (an absolute path)
  87                 dirEnd = 1;
  88         return B_OK;
  89 }
  90
  91 // parse_path
  92 /*!     \brief Parses the supplied path and returns the leaf name part of the path
  93                    and its directory path part.
  94
  95         The value returned in \a fullPath is guaranteed to be > 0, i.e. the
  96         function always returns a non-empty directory path part. The leaf name
  97         part may be empty though (i.e. \code leafStart == leafEnd \endcode), which
  98         will happen, if the supplied path consists only of one component.
  99
 100         \param fullPath The path to be parsed.
 101         \param dirPath Pointer to a character array of size \c B_PATH_NAME_LENGTH
 102                    or greater, into which the directory part shall be written.
 103                    May be \c NULL.
 104         \param leaf Pointer to a character array of size \c B_FILE_NAME_LENGTH
 105                    or greater, into which the leaf name part shall be written.
 106                    May be \c NULL.
 107         \return \c B_OK, if everything went fine, B_BAD_VALUE, if the supplied
 108                    path is invalid.
 109 */
 110 status_t
 111 parse_path(const char *fullPath, char *dirPath, char *leaf)
 112 {
 113         // parse the path and check the lengths
 114         int leafStart, leafEnd, dirEnd;
 115         status_t error = parse_path(fullPath, dirEnd, leafStart, leafEnd);
 116         if (error != B_OK)
 117                 return error;
 118         if (dirEnd >= B_PATH_NAME_LENGTH
 119                 || leafEnd - leafStart >= B_FILE_NAME_LENGTH) {
 120                 return B_NAME_TOO_LONG;
 121         }
 122         // copy the result strings
 123         if (dirPath)
 124                 strlcpy(dirPath, fullPath, dirEnd + 1);
 125         if (leaf)
 126                 strlcpy(leaf, fullPath + leafStart, leafEnd - leafStart + 1);
 127         return B_OK;
 128 }
 129
 130 // internal_parse_path
 131 static
 132 void
 133 internal_parse_path(const char *fullPath, int &leafStart, int &leafEnd,
 134         int &pathEnd)
 135 {
 136         if (fullPath == NULL)
 137                 return;
 138
 139         enum PathParserState { PPS_START, PPS_LEAF } state = PPS_START;
 140
 141         int len = strlen(fullPath);
 142
 143         leafStart = -1;
 144         leafEnd = -1;
 145         pathEnd = -2;
 146
 147         bool loop = true;
 148         for (int pos = len-1; ; pos--) {
 149                 if (pos < 0)
 150                         break;
 151
 152                 switch (state) {
 153                         case PPS_START:
 154                                 // Skip all trailing '/' chars, then move on to
 155                                 // reading the leaf name
 156                                 if (fullPath[pos] != '/') {
 157                                         leafEnd = pos;
 158                                         state = PPS_LEAF;
 159                                 }
 160                                 break;
 161
 162                         case PPS_LEAF:
 163                                 // Read leaf name chars until we hit a '/' char
 164                                 if (fullPath[pos] == '/') {
 165                                         leafStart = pos+1;
 166                                         pathEnd = pos-1;
 167                                         loop = false;
 168                                 }
 169                                 break;
 170                 }
 171
 172                 if (!loop)
 173                         break;
 174         }
 175 }
 176
 177 /*!     The caller is responsible for deleting the returned directory path name
 178         and the leaf name.
 179         \param fullPath the path name to be split
 180         \param path a variable the directory path name pointer shall
 181                    be written into, may be NULL
 182         \param leaf a variable the leaf name pointer shall be
 183                    written into, may be NULL
 184 */
 185 status_t
 186 split_path(const char *fullPath, char *&path, char *&leaf)
 187 {
 188         return split_path(fullPath, &path, &leaf);
 189 }
 190
 191 /*!     The caller is responsible for deleting the returned directory path name
 192         and the leaf name.
 193         \param fullPath the path name to be split
 194         \param path a pointer to a variable the directory path name pointer shall
 195                    be written into, may be NULL
 196         \param leaf a pointer to a variable the leaf name pointer shall be
 197                    written into, may be NULL
 198 */
 199 status_t
 200 split_path(const char *fullPath, char **path, char **leaf)
 201 {
 202         if (path)
 203                 *path = NULL;
 204         if (leaf)
 205                 *leaf = NULL;
 206
 207         if (fullPath == NULL)
 208                 return B_BAD_VALUE;
 209
 210         int leafStart, leafEnd, pathEnd, len;
 211         internal_parse_path(fullPath, leafStart, leafEnd, pathEnd);
 212
 213         try {
 214                 // Tidy up/handle special cases
 215                 if (leafEnd == -1) {
 216
 217                         // Handle special cases
 218                         if (fullPath[0] == '/') {
 219                                 // Handle "/"
 220                                 if (path) {
 221                                         *path = new char[2];
 222                                         (*path)[0] = '/';
 223                                         (*path)[1] = 0;
 224                                 }
 225                                 if (leaf) {
 226                                         *leaf = new char[2];
 227                                         (*leaf)[0] = '.';
 228                                         (*leaf)[1] = 0;
 229                                 }
 230                                 return B_OK;
 231                         } else if (fullPath[0] == 0) {
 232                                 // Handle "", which we'll treat as "./"
 233                                 if (path) {
 234                                         *path = new char[1];
 235                                         (*path)[0] = 0;
 236                                 }
 237                                 if (leaf) {
 238                                         *leaf = new char[2];
 239                                         (*leaf)[0] = '.';
 240                                         (*leaf)[1] = 0;
 241                                 }
 242                                 return B_OK;
 243                         }
 244
 245                 } else if (leafStart == -1) {
 246                         // fullPath is just an entry name, no parent directories specified
 247                         leafStart = 0;
 248                 } else if (pathEnd == -1) {
 249                         // The path is '/' (since pathEnd would be -2 if we had
 250                         // run out of characters before hitting a '/')
 251                         pathEnd = 0;
 252                 }
 253
 254                 // Alloc new strings and copy the path and leaf over
 255                 if (path) {
 256                         if (pathEnd == -2) {
 257                                 // empty path
 258                                 *path = new char[2];
 259                                 (*path)[0] = '.';
 260                                 (*path)[1] = 0;
 261                         } else {
 262                                 // non-empty path
 263                                 len = pathEnd + 1;
 264                                 *path = new char[len+1];
 265                                 memcpy(*path, fullPath, len);
 266                                 (*path)[len] = 0;
 267                         }
 268                 }
 269                 if (leaf) {
 270                         len = leafEnd - leafStart + 1;
 271                         *leaf = new char[len+1];
 272                         memcpy(*leaf, fullPath + leafStart, len);
 273                         (*leaf)[len] = 0;
 274                 }
 275         } catch (std::bad_alloc exception) {
 276                 if (path)
 277                         delete[] *path;
 278                 if (leaf)
 279                         delete[] *leaf;
 280                 return B_NO_MEMORY;
 281         }
 282         return B_OK;
 283 }
 284
 285 /*! The length of the first component is returned as well as the index at
 286         which the next one starts. These values are only valid, if the function
 287         returns \c B_OK.
 288         \param path the path to be parsed
 289         \param length the variable the length of the first component is written
 290                    into
 291         \param nextComponent the variable the index of the next component is
 292                    written into. \c 0 is returned, if there is no next component.
 293         \return \c B_OK, if \a path is not \c NULL, \c B_BAD_VALUE otherwise
 294 */
 295 status_t
 296 parse_first_path_component(const char *path, int32& length,
 297                                                    int32& nextComponent)
 298 {
 299         status_t error = (path ? B_OK : B_BAD_VALUE);
 300         if (error == B_OK) {
 301                 int32 i = 0;
 302                 // find first '/' or end of name
 303                 for (; path[i] != '/' && path[i] != '\0'; i++);
 304                 // handle special case "/..." (absolute path)
 305                 if (i == 0 && path[i] != '\0')
 306                         i = 1;
 307                 length = i;
 308                 // find last '/' or end of name
 309                 for (; path[i] == '/' && path[i] != '\0'; i++);
 310                 if (path[i] == '\0')    // this covers "" as well
 311                         nextComponent = 0;
 312                 else
 313                         nextComponent = i;
 314         }
 315         return error;
 316 }
 317
 318 /*! A string containing the first component is returned and the index, at
 319         which the next one starts. These values are only valid, if the function
 320         returns \c B_OK.
 321         \param path the path to be parsed
 322         \param component the variable the pointer to the newly allocated string
 323                    containing the first path component is written into. The caller
 324                    is responsible for delete[]'ing the string.
 325         \param nextComponent the variable the index of the next component is
 326                    written into. \c 0 is returned, if there is no next component.
 327         \return \c B_OK, if \a path is not \c NULL, \c B_BAD_VALUE otherwise
 328 */
 329 status_t
 330 parse_first_path_component(const char *path, char *&component,
 331                                                    int32& nextComponent)
 332 {
 333         int32 length;
 334         status_t error = parse_first_path_component(path, length, nextComponent);
 335         if (error == B_OK) {
 336                 component = new(nothrow) char[length + 1];
 337                 if (component) {
 338                         strncpy(component, path, length);
 339                         component[length] = '\0';
 340                 } else
 341                         error = B_NO_MEMORY;
 342         }
 343         return error;
 344 }
 345
 346 /*!     An entry name is considered valid, if its length doesn't exceed
 347         \c B_FILE_NAME_LENGTH (including the terminating null) and it doesn't
 348         contain any \c "/".
 349         \param entry the entry name
 350         \return
 351         - \c B_OK, if \a entry is valid,
 352         - \c B_BAD_VALUE, if \a entry is \c NULL or contains a "/",
 353         - \c B_NAME_TOO_LONG, if \a entry is too long
 354         \note \c "" is considered a valid entry name.
 355 */
 356 status_t
 357 check_entry_name(const char *entry)
 358 {
 359         status_t error = (entry ? B_OK : B_BAD_VALUE);
 360         if (error == B_OK) {
 361                 if (strlen(entry) >= B_FILE_NAME_LENGTH)
 362                         error = B_NAME_TOO_LONG;
 363         }
 364         if (error == B_OK) {
 365                 for (int32 i = 0; error == B_OK && entry[i] != '\0'; i++) {
 366                         if (entry[i] == '/')
 367                                 error = B_BAD_VALUE;
 368                 }
 369         }
 370         return error;
 371 }
 372
 373 /*!     An path name is considered valid, if its length doesn't exceed
 374         \c B_PATH_NAME_LENGTH (including the terminating null) and each of
 375         its components is a valid entry name.
 376         \param entry the entry name
 377         \return
 378         - \c B_OK, if \a path is valid,
 379         - \c B_BAD_VALUE, if \a path is \c NULL,
 380         - \c B_NAME_TOO_LONG, if \a path, or any of its components is too long
 381         \note \c "" is considered a valid path name.
 382 */
 383 status_t
 384 check_path_name(const char *path)
 385 {
 386         status_t error = (path ? B_OK : B_BAD_VALUE);
 387         // check the path components
 388         const char *remainder = path;
 389         int32 length, nextComponent;
 390         do {
 391                 error = parse_first_path_component(remainder, length, nextComponent);
 392                 if (error == B_OK) {
 393                         if (length >= B_FILE_NAME_LENGTH)
 394                                 error = B_NAME_TOO_LONG;
 395                         remainder += nextComponent;
 396                 }
 397         } while (error == B_OK && nextComponent != 0);
 398         // check the length of the path
 399         if (error == B_OK && strlen(path) >= B_PATH_NAME_LENGTH)
 400                 error = B_NAME_TOO_LONG;
 401         return error;
 402 }
 403
 404 std::string
 405 to_lower(const char *str)
 406 {
 407         std::string result;
 408         to_lower(str, result);
 409         return result;
 410 }
 411
 412 void
 413 to_lower(const char *str, std::string &result)
 414 {
 415         if (str) {
 416                 result = "";
 417                 for (int i = 0; i < (int)strlen(str); i++)
 418                         result += tolower(str[i]);
 419         } else
 420                 result = "(null)";
 421 }
 422
 423 void
 424 to_lower(const char *str, char *result)
 425 {
 426         if (str && result) {
 427                 int i;
 428                 for (i = 0; i < (int)strlen(str); i++)
 429                         result[i] = tolower(str[i]);
 430                 result[i] = 0;
 431         }
 432 }
 433
 434 void
 435 to_lower(char *str)
 436 {
 437         to_lower(str, str);
 438 }
 439
 440 void escape_path(const char *str, char *result)
 441 {
 442         if (str && result) {
 443                 int32 len = strlen(str);
 444
 445                 for (int32 i = 0; i < len; i++) {
 446                         char ch = str[i];
 447                         char escapeChar = 0;
 448
 449                         switch (ch) {
 450                                 case ' ':
 451                                 case '\'':
 452                                 case '"':
 453                                 case '?':
 454                                 case '\\':
 455                                 case '(':
 456                                 case ')':
 457                                 case '[':
 458                                 case ']':
 459                                 case '*':
 460                                 case '^':
 461                                         escapeChar = ch;
 462                                         break;
 463                         }
 464
 465                         if (escapeChar) {
 466                                 *(result++) = '\\';
 467                                 *(result++) = escapeChar;
 468                         } else {
 469                                 *(result++) = ch;
 470                         }
 471                 }
 472
 473                 *result = 0;
 474         }
 475 }
 476
 477 void escape_path(char *str)
 478 {
 479         if (str) {
 480                 char *copy = new(nothrow) char[strlen(str)+1];
 481                 if (copy) {
 482                         strcpy(copy, str);
 483                         escape_path(copy, str);
 484                 }
 485                 delete [] copy;
 486         }
 487 }
 488
 489 // device_is_root_device
 490 bool
 491 device_is_root_device(dev_t device)
 492 {
 493         return device == 1;
 494 }
 495
 496 // Close
 497 void
 498 FDCloser::Close()
 499 {
 500         if (fFD >= 0)
 501                 _kern_close(fFD);
 502         fFD = -1;
 503 }
 504
 505 };      // namespace Storage
 506 };      // namespace BPrivate
 507