Mercurial > irccd
annotate common/path.cpp @ 25:afff3f16d86e
Docs: explain better plugin-reload, #421
| author | David Demelier <markand@malikania.fr> |
|---|---|
| date | Tue, 16 Feb 2016 13:58:29 +0100 |
| parents | 03068f5ed79d |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 * path.cpp -- special paths inside irccd | |
| 3 * | |
| 4 * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr> | |
| 5 * | |
| 6 * Permission to use, copy, modify, and/or distribute this software for any | |
| 7 * purpose with or without fee is hereby granted, provided that the above | |
| 8 * copyright notice and this permission notice appear in all copies. | |
| 9 * | |
| 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
| 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
| 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
| 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
| 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
| 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
| 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
| 17 */ | |
| 18 | |
| 19 #include <algorithm> | |
| 20 #include <cassert> | |
| 21 #include <sstream> | |
| 22 #include <stdexcept> | |
| 23 | |
| 24 #include <irccd-config.h> | |
| 25 | |
| 26 #if defined(IRCCD_SYSTEM_WINDOWS) | |
| 27 # include <Windows.h> | |
| 28 # include <Shlobj.h> | |
| 29 #else | |
| 30 # if defined(IRCCD_SYSTEM_LINUX) | |
| 31 # include <limits.h> | |
| 32 # include <unistd.h> | |
| 33 # include <cerrno> | |
| 34 # include <cstring> | |
| 35 # include <stdexcept> | |
| 36 # endif | |
| 37 | |
| 38 # if defined(IRCCD_SYSTEM_FREEBSD) | |
| 39 # include <sys/types.h> | |
| 40 # include <sys/sysctl.h> | |
| 41 # include <limits.h> | |
| 42 | |
| 43 # include <array> | |
| 44 # include <cerrno> | |
| 45 # include <cstring> | |
| 46 # include <stdexcept> | |
| 47 # endif | |
| 48 | |
| 49 # if defined(IRCCD_SYSTEM_MAC) | |
| 50 # include <cerrno> | |
| 51 # include <cstring> | |
| 52 # include <unistd.h> | |
| 53 # include <libproc.h> | |
| 54 # endif | |
| 55 | |
| 56 # include <xdg.h> | |
| 57 #endif | |
| 58 | |
| 59 #include "filesystem.h" | |
| 60 #include "path.h" | |
| 61 #include "system.h" | |
| 62 #include "util.h" | |
| 63 | |
| 64 namespace irccd { | |
| 65 | |
| 66 namespace path { | |
| 67 | |
| 68 namespace { | |
| 69 | |
| 70 /* | |
| 71 * Base program directory | |
| 72 * ------------------------------------------------------------------ | |
| 73 * | |
| 74 * This variable stores the program base directory. It is only enabled when irccd is relocatable because we can | |
| 75 * retrieve the base directory by removing WITH_BINDIR. | |
| 76 * | |
| 77 * If it is empty, the program was not able to detect it (e.g. error, not supported). | |
| 78 */ | |
| 79 | |
| 80 #if defined(IRCCD_RELOCATABLE) | |
| 81 | |
| 82 std::string base; | |
| 83 | |
| 84 #if defined(IRCCD_SYSTEM_WINDOWS) | |
| 85 | |
| 86 std::string executablePath() | |
| 87 { | |
| 88 std::string result; | |
| 89 std::size_t size = PATH_MAX; | |
| 90 | |
| 91 result.resize(size); | |
| 92 | |
| 93 if (!(size = GetModuleFileNameA(nullptr, &result[0], size))) | |
|
23
03068f5ed79d
Misc: various style issues, #419
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
94 throw std::runtime_error("GetModuleFileName error"); |
| 0 | 95 |
| 96 result.resize(size); | |
| 97 | |
| 98 return result; | |
| 99 } | |
| 100 | |
| 101 #elif defined(IRCCD_SYSTEM_LINUX) | |
| 102 | |
| 103 std::string executablePath() | |
| 104 { | |
| 105 std::string result; | |
| 106 | |
| 107 result.resize(2048); | |
| 108 | |
| 109 auto size = readlink("/proc/self/exe", &result[0], 2048); | |
| 110 | |
| 111 if (size < 0) | |
|
23
03068f5ed79d
Misc: various style issues, #419
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
112 throw std::invalid_argument(std::strerror(errno)); |
| 0 | 113 |
| 114 result.resize(size); | |
| 115 | |
| 116 return result; | |
| 117 } | |
| 118 | |
| 119 #elif defined(IRCCD_SYSTEM_FREEBSD) | |
| 120 | |
| 121 std::string executablePath() | |
| 122 { | |
| 123 std::array<int, 4> mib{ { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 } }; | |
| 124 std::string result; | |
| 125 std::size_t size = PATH_MAX + 1; | |
| 126 | |
| 127 result.resize(size); | |
| 128 | |
| 129 if (sysctl(mib.data(), 4, &result[0], &size, nullptr, 0) < 0) | |
|
23
03068f5ed79d
Misc: various style issues, #419
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
130 throw std::runtime_error(std::strerror(errno)); |
| 0 | 131 |
| 132 result.resize(size); | |
| 133 | |
| 134 return result; | |
| 135 } | |
| 136 | |
| 137 #elif defined(IRCCD_SYSTEM_MAC) | |
| 138 | |
| 139 std::string executablePath() | |
| 140 { | |
| 141 std::string result; | |
| 142 std::size_t size = PROC_PIDPATHINFO_MAXSIZE; | |
| 143 | |
| 144 result.resize(size); | |
| 145 | |
| 146 if ((size = proc_pidpath(getpid(), &result[0], size)) == 0) | |
|
23
03068f5ed79d
Misc: various style issues, #419
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
147 throw std::runtime_error(std::strerror(errno)); |
| 0 | 148 |
| 149 result.resize(size); | |
| 150 | |
| 151 return result; | |
| 152 } | |
| 153 | |
| 154 #else | |
| 155 | |
| 156 /* | |
| 157 * TODO: add support for more systems here. | |
| 158 * | |
| 159 * - NetBSD | |
| 160 * - OpenBSD | |
| 161 */ | |
| 162 | |
| 163 std::string executablePath() | |
| 164 { | |
| 165 return ""; | |
| 166 } | |
| 167 | |
| 168 #endif | |
| 169 | |
| 170 #endif // !IRCCD_RELOCATABLE | |
| 171 | |
| 172 /* | |
| 173 * System paths | |
| 174 * ------------------------------------------------------------------ | |
| 175 * | |
| 176 * Compute system paths. | |
| 177 * | |
| 178 * Do not call any of these functions if irccd is relocatable and base is unset. | |
| 179 */ | |
| 180 | |
| 181 std::string systemConfig() | |
| 182 { | |
| 183 #if defined(IRCCD_RELOCATABLE) | |
| 184 assert(!base.empty()); | |
| 185 | |
| 186 return base + WITH_CONFDIR; | |
| 187 #else | |
| 188 return fs::isAbsolute(WITH_CONFDIR) ? WITH_CONFDIR : std::string(PREFIX) + fs::Separator + WITH_CONFDIR; | |
| 189 #endif | |
| 190 } | |
| 191 | |
| 192 std::string systemData() | |
| 193 { | |
| 194 #if defined(IRCCD_RELOCATABLE) | |
| 195 assert(!base.empty()); | |
| 196 | |
| 197 return base + WITH_DATADIR; | |
| 198 #else | |
| 199 return fs::isAbsolute(WITH_DATADIR) ? WITH_CONFDIR : std::string(PREFIX) + fs::Separator + WITH_DATADIR; | |
| 200 #endif | |
| 201 } | |
| 202 | |
| 203 std::string systemCache() | |
| 204 { | |
| 205 #if defined(IRCCD_RELOCATABLE) | |
| 206 assert(!base.empty()); | |
| 207 | |
| 208 return base + WITH_CACHEDIR; | |
| 209 #else | |
| 210 return fs::isAbsolute(WITH_CACHEDIR) ? WITH_CACHEDIR : std::string(PREFIX) + fs::Separator + WITH_CACHEDIR; | |
| 211 #endif | |
| 212 } | |
| 213 | |
| 214 std::string systemPlugins() | |
| 215 { | |
| 216 #if defined(IRCCD_RELOCATABLE) | |
| 217 assert(!base.empty()); | |
| 218 | |
| 219 return base + WITH_PLUGINDIR; | |
| 220 #else | |
| 221 return fs::isAbsolute(WITH_PLUGINDIR) ? WITH_PLUGINDIR : std::string(PREFIX) + fs::Separator + WITH_PLUGINDIR; | |
| 222 #endif | |
| 223 } | |
| 224 | |
| 225 /* | |
| 226 * User paths | |
| 227 * ------------------------------------------------------------------ | |
| 228 * | |
| 229 * Compute user paths. | |
| 230 */ | |
| 231 | |
| 232 /* | |
| 233 * userConfig | |
| 234 * --------------------------------------------------------- | |
| 235 * | |
| 236 * Get the path directory to the user configuration. Example: | |
| 237 * | |
| 238 * Unix: | |
| 239 * | |
| 240 * XDG_CONFIG_HOME/irccd | |
| 241 * HOME/.config/irccd | |
| 242 * | |
| 243 * Windows: | |
| 244 * | |
| 245 * CSIDL_LOCAL_APPDATA/irccd/config | |
| 246 */ | |
| 247 std::string userConfig() | |
| 248 { | |
| 249 std::ostringstream oss; | |
| 250 | |
| 251 #if defined(IRCCD_SYSTEM_WINDOWS) | |
| 252 char path[MAX_PATH]; | |
| 253 | |
| 254 if (SHGetFolderPathA(nullptr, CSIDL_LOCAL_APPDATA, nullptr, 0, path) != S_OK) { | |
| 255 oss << ""; | |
| 256 } else { | |
| 257 oss << path; | |
| 258 oss << "\\irccd\\config\\"; | |
| 259 } | |
| 260 #else | |
| 261 try { | |
| 262 Xdg xdg; | |
| 263 | |
| 264 oss << xdg.configHome(); | |
| 265 oss << "/irccd/"; | |
| 266 } catch (const std::exception &) { | |
| 267 const char *home = getenv("HOME"); | |
| 268 | |
| 269 if (home != nullptr) | |
| 270 oss << home; | |
| 271 | |
| 272 oss << "/.config/irccd/"; | |
| 273 } | |
| 274 #endif | |
| 275 | |
| 276 return oss.str(); | |
| 277 } | |
| 278 | |
| 279 /* | |
| 280 * userData | |
| 281 * -------------------------------------------------------- | |
| 282 * | |
| 283 * Get the path to the data application. | |
| 284 * | |
| 285 * Unix: | |
| 286 * | |
| 287 * XDG_DATA_HOME/irccd | |
| 288 * HOME/.local/share/irccd | |
| 289 * | |
| 290 * Windows: | |
| 291 * | |
| 292 * CSIDL_LOCAL_APPDATA | |
| 293 */ | |
| 294 std::string userData() | |
| 295 { | |
| 296 std::ostringstream oss; | |
| 297 | |
| 298 #if defined(IRCCD_SYSTEM_WINDOWS) | |
| 299 char path[MAX_PATH]; | |
| 300 | |
| 301 if (SHGetFolderPathA(nullptr, CSIDL_LOCAL_APPDATA, nullptr, 0, path) != S_OK) | |
| 302 oss << ""; | |
| 303 else { | |
| 304 oss << path; | |
| 305 oss << "\\irccd\\share"; | |
| 306 } | |
| 307 #else | |
| 308 try { | |
| 309 Xdg xdg; | |
| 310 | |
| 311 oss << xdg.dataHome(); | |
| 312 oss << "/irccd/"; | |
| 313 } catch (const std::exception &) { | |
| 314 const char *home = getenv("HOME"); | |
| 315 | |
| 316 if (home != nullptr) | |
| 317 oss << home; | |
| 318 | |
| 319 oss << "/.local/share/irccd/"; | |
| 320 } | |
| 321 #endif | |
| 322 | |
| 323 return oss.str(); | |
| 324 } | |
| 325 | |
| 326 /* | |
| 327 * userCache | |
| 328 * -------------------------------------------------------- | |
| 329 * | |
| 330 * Directory for cache files. | |
| 331 * | |
| 332 * Unix: | |
| 333 * | |
| 334 * XDG_CACHE_HOME/irccd | |
| 335 * HOME/.cache/irccd | |
| 336 * | |
| 337 * Windows: | |
| 338 * | |
| 339 * %TEMP% (e.g. C:\Users\<user>\AppData\Local\Temp) | |
| 340 */ | |
| 341 std::string userCache() | |
| 342 { | |
| 343 std::ostringstream oss; | |
| 344 | |
| 345 #if defined(IRCCD_SYSTEM_WINDOWS) | |
| 346 char path[MAX_PATH + 1]; | |
| 347 | |
| 348 GetTempPathA(sizeof (path), path); | |
| 349 | |
| 350 oss << path << "\\irccd\\"; | |
| 351 #else | |
| 352 try { | |
| 353 Xdg xdg; | |
| 354 | |
| 355 oss << xdg.cacheHome(); | |
| 356 oss << "/irccd/"; | |
| 357 } catch (const std::exception &) { | |
| 358 const char *home = getenv("HOME"); | |
| 359 | |
| 360 if (home != nullptr) | |
| 361 oss << home; | |
| 362 | |
| 363 oss << "/.cache/irccd/"; | |
| 364 } | |
| 365 #endif | |
| 366 | |
| 367 return oss.str(); | |
| 368 } | |
| 369 | |
| 370 /* | |
| 371 * userPlugins | |
| 372 * -------------------------------------------------------- | |
| 373 * | |
| 374 * Path to the data + plugins. | |
| 375 */ | |
| 376 std::string userPlugins() | |
| 377 { | |
| 378 return userData() + "/plugins/"; | |
| 379 } | |
| 380 | |
| 381 } // !namespace | |
| 382 | |
| 383 #if defined(IRCCD_SYSTEM_WINDOWS) | |
|
23
03068f5ed79d
Misc: various style issues, #419
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
384 const char Separator(';'); |
| 0 | 385 #else |
|
23
03068f5ed79d
Misc: various style issues, #419
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
386 const char Separator(':'); |
| 0 | 387 #endif |
| 388 | |
| 389 void setApplicationPath(const std::string &argv0) | |
| 390 { | |
| 391 #if defined(IRCCD_RELOCATABLE) | |
| 392 try { | |
| 393 base = executablePath(); | |
| 394 } catch (const std::exception &) { | |
| 395 /* | |
| 396 * If an exception is thrown, that means the operatin system supports a function to get the executable | |
| 397 * path but it failed. | |
| 398 * | |
| 399 * TODO: show a waning | |
| 400 */ | |
| 401 } | |
| 402 | |
| 403 /* | |
| 404 * If we could not get the application path from the native function, check if argv[0] is an absolute path | |
| 405 * and use that from there. | |
| 406 * | |
| 407 * Otherwise, search from the PATH. | |
| 408 * | |
| 409 * In the worst case use current working directory. | |
| 410 */ | |
| 411 if (base.empty()) { | |
| 412 if (fs::isAbsolute(argv0)) { | |
| 413 base = argv0; | |
| 414 } else { | |
| 415 std::string name = fs::baseName(argv0); | |
| 416 | |
| 417 for (const auto &dir : util::split(sys::env("PATH"), std::string(1, Separator))) { | |
| 418 std::string path = dir + fs::Separator + name; | |
| 419 | |
| 420 if (fs::exists(path)) { | |
| 421 base = path; | |
| 422 break; | |
| 423 } | |
| 424 } | |
| 425 | |
| 426 /* Not found in PATH? add dummy value */ | |
|
23
03068f5ed79d
Misc: various style issues, #419
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
427 if (base.empty()) |
| 0 | 428 base = std::string(".") + fs::Separator + WITH_BINDIR + fs::Separator + "dummy"; |
| 429 } | |
| 430 } | |
| 431 | |
| 432 /* Find bin/<progname> */ | |
| 433 auto pos = base.rfind(std::string(WITH_BINDIR) + fs::Separator + fs::baseName(base)); | |
| 434 | |
| 435 if (pos != std::string::npos) | |
| 436 base.erase(pos); | |
| 437 | |
| 438 /* Add trailing / or \\ for convenience */ | |
| 439 base = clean(base); | |
| 440 | |
| 441 assert(!base.empty()); | |
| 442 #else | |
| 443 (void)argv0; | |
| 444 #endif | |
| 445 } | |
| 446 | |
| 447 std::string clean(std::string input) | |
| 448 { | |
| 449 if (input.empty()) | |
| 450 return input; | |
| 451 | |
| 452 /* First, remove any duplicates */ | |
| 453 input.erase(std::unique(input.begin(), input.end(), [&] (char c1, char c2) { | |
| 454 return c1 == c2 && (c1 == '/' || c1 == '\\'); | |
| 455 }), input.end()); | |
| 456 | |
| 457 /* Add a trailing / or \\ */ | |
| 458 char c = input[input.length() - 1]; | |
| 459 if (c != '/' && c != '\\') | |
| 460 input += fs::Separator; | |
| 461 | |
| 462 /* Now converts all / to \\ for Windows and the opposite for Unix */ | |
| 463 #if defined(IRCCD_SYSTEM_WINDOWS) | |
| 464 std::replace(input.begin(), input.end(), '/', '\\'); | |
| 465 #else | |
| 466 std::replace(input.begin(), input.end(), '\\', '/'); | |
| 467 #endif | |
| 468 | |
| 469 return input; | |
| 470 } | |
| 471 | |
| 472 std::string get(Path path, Owner owner) | |
| 473 { | |
| 474 assert(path >= PathConfig && path <= PathPlugins); | |
| 475 assert(owner >= OwnerSystem && owner <= OwnerUser); | |
| 476 | |
| 477 std::string result; | |
| 478 | |
| 479 switch (owner) { | |
| 480 case OwnerSystem: | |
| 481 switch (path) { | |
| 482 case PathCache: | |
| 483 result = clean(systemCache()); | |
| 484 break; | |
| 485 case PathConfig: | |
| 486 result = clean(systemConfig()); | |
| 487 break; | |
| 488 case PathData: | |
| 489 result = clean(systemData()); | |
| 490 break; | |
| 491 case PathPlugins: | |
| 492 result = clean(systemPlugins()); | |
| 493 break; | |
| 494 default: | |
| 495 break; | |
| 496 } | |
| 497 case OwnerUser: | |
| 498 switch (path) { | |
| 499 case PathCache: | |
| 500 result = clean(userCache()); | |
| 501 break; | |
| 502 case PathConfig: | |
| 503 result = clean(userConfig()); | |
| 504 break; | |
| 505 case PathData: | |
| 506 result = clean(userData()); | |
| 507 break; | |
| 508 case PathPlugins: | |
| 509 result = clean(userPlugins()); | |
| 510 break; | |
| 511 default: | |
| 512 break; | |
| 513 } | |
| 514 default: | |
| 515 break; | |
| 516 } | |
| 517 | |
| 518 return result; | |
| 519 } | |
| 520 | |
| 521 std::vector<std::string> list(Path path) | |
| 522 { | |
| 523 assert(path >= PathConfig && path <= PathPlugins); | |
| 524 | |
| 525 std::vector<std::string> list; | |
| 526 | |
| 527 switch (path) { | |
| 528 case PathCache: | |
| 529 list.push_back(clean(userCache())); | |
| 530 list.push_back(clean(systemCache())); | |
| 531 break; | |
| 532 case PathConfig: | |
| 533 list.push_back(clean(userConfig())); | |
| 534 list.push_back(clean(systemConfig())); | |
| 535 break; | |
| 536 case PathData: | |
| 537 list.push_back(clean(userData())); | |
| 538 list.push_back(clean(systemData())); | |
| 539 break; | |
| 540 case PathPlugins: | |
| 541 list.push_back(clean(fs::cwd())); | |
| 542 list.push_back(clean(userPlugins())); | |
| 543 list.push_back(clean(systemPlugins())); | |
| 544 break; | |
| 545 default: | |
| 546 break; | |
| 547 } | |
| 548 | |
| 549 return list; | |
| 550 } | |
| 551 | |
| 552 } // !path | |
| 553 | |
| 554 } // !irccd |