You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

287 lines
7.7 KiB

  1. #include "store-api.hh"
  2. #include "globals.hh"
  3. #include "util.hh"
  4. #include <climits>
  5. namespace nix {
  6. GCOptions::GCOptions()
  7. {
  8. action = gcDeleteDead;
  9. ignoreLiveness = false;
  10. maxFreed = ULLONG_MAX;
  11. }
  12. bool isInStore(const Path & path)
  13. {
  14. return isInDir(path, settings.nixStore);
  15. }
  16. bool isStorePath(const Path & path)
  17. {
  18. return isInStore(path)
  19. && path.find('/', settings.nixStore.size() + 1) == Path::npos;
  20. }
  21. void assertStorePath(const Path & path)
  22. {
  23. if (!isStorePath(path))
  24. throw Error(format("path `%1%' is not in the Nix store") % path);
  25. }
  26. Path toStorePath(const Path & path)
  27. {
  28. if (!isInStore(path))
  29. throw Error(format("path `%1%' is not in the Nix store") % path);
  30. Path::size_type slash = path.find('/', settings.nixStore.size() + 1);
  31. if (slash == Path::npos)
  32. return path;
  33. else
  34. return Path(path, 0, slash);
  35. }
  36. string storePathToName(const Path & path)
  37. {
  38. assertStorePath(path);
  39. return string(path, settings.nixStore.size() + 34);
  40. }
  41. void checkStoreName(const string & name)
  42. {
  43. string validChars = "+-._?=";
  44. /* Disallow names starting with a dot for possible security
  45. reasons (e.g., "." and ".."). */
  46. if (string(name, 0, 1) == ".")
  47. throw Error(format("illegal name: `%1%'") % name);
  48. foreach (string::const_iterator, i, name)
  49. if (!((*i >= 'A' && *i <= 'Z') ||
  50. (*i >= 'a' && *i <= 'z') ||
  51. (*i >= '0' && *i <= '9') ||
  52. validChars.find(*i) != string::npos))
  53. {
  54. throw Error(format("invalid character `%1%' in name `%2%'")
  55. % *i % name);
  56. }
  57. }
  58. /* Store paths have the following form:
  59. <store>/<h>-<name>
  60. where
  61. <store> = the location of the Nix store, usually /nix/store
  62. <name> = a human readable name for the path, typically obtained
  63. from the name attribute of the derivation, or the name of the
  64. source file from which the store path is created. For derivation
  65. outputs other than the default "out" output, the string "-<id>"
  66. is suffixed to <name>.
  67. <h> = base-32 representation of the first 160 bits of a SHA-256
  68. hash of <s>; the hash part of the store name
  69. <s> = the string "<type>:sha256:<h2>:<store>:<name>";
  70. note that it includes the location of the store as well as the
  71. name to make sure that changes to either of those are reflected
  72. in the hash (e.g. you won't get /nix/store/<h>-name1 and
  73. /nix/store/<h>-name2 with equal hash parts).
  74. <type> = one of:
  75. "text:<r1>:<r2>:...<rN>"
  76. for plain text files written to the store using
  77. addTextToStore(); <r1> ... <rN> are the references of the
  78. path.
  79. "source"
  80. for paths copied to the store using addToStore() when recursive
  81. = true and hashAlgo = "sha256"
  82. "output:<id>"
  83. for either the outputs created by derivations, OR paths copied
  84. to the store using addToStore() with recursive != true or
  85. hashAlgo != "sha256" (in that case "source" is used; it's
  86. silly, but it's done that way for compatibility). <id> is the
  87. name of the output (usually, "out").
  88. <h2> = base-16 representation of a SHA-256 hash of:
  89. if <type> = "text:...":
  90. the string written to the resulting store path
  91. if <type> = "source":
  92. the serialisation of the path from which this store path is
  93. copied, as returned by hashPath()
  94. if <type> = "output:out":
  95. for non-fixed derivation outputs:
  96. the derivation (see hashDerivationModulo() in
  97. primops.cc)
  98. for paths copied by addToStore() or produced by fixed-output
  99. derivations:
  100. the string "fixed:out:<rec><algo>:<hash>:", where
  101. <rec> = "r:" for recursive (path) hashes, or "" or flat
  102. (file) hashes
  103. <algo> = "md5", "sha1" or "sha256"
  104. <hash> = base-16 representation of the path or flat hash of
  105. the contents of the path (or expected contents of the
  106. path for fixed-output derivations)
  107. It would have been nicer to handle fixed-output derivations under
  108. "source", e.g. have something like "source:<rec><algo>", but we're
  109. stuck with this for now...
  110. The main reason for this way of computing names is to prevent name
  111. collisions (for security). For instance, it shouldn't be feasible
  112. to come up with a derivation whose output path collides with the
  113. path for a copied source. The former would have a <s> starting with
  114. "output:out:", while the latter would have a <2> starting with
  115. "source:".
  116. */
  117. Path makeStorePath(const string & type,
  118. const Hash & hash, const string & name)
  119. {
  120. /* e.g., "source:sha256:1abc...:/nix/store:foo.tar.gz" */
  121. string s = type + ":sha256:" + printHash(hash) + ":"
  122. + settings.nixStore + ":" + name;
  123. checkStoreName(name);
  124. return settings.nixStore + "/"
  125. + printHash32(compressHash(hashString(htSHA256, s), 20))
  126. + "-" + name;
  127. }
  128. Path makeOutputPath(const string & id,
  129. const Hash & hash, const string & name)
  130. {
  131. return makeStorePath("output:" + id, hash,
  132. name + (id == "out" ? "" : "-" + id));
  133. }
  134. Path makeFixedOutputPath(bool recursive,
  135. HashType hashAlgo, Hash hash, string name)
  136. {
  137. return hashAlgo == htSHA256 && recursive
  138. ? makeStorePath("source", hash, name)
  139. : makeStorePath("output:out", hashString(htSHA256,
  140. "fixed:out:" + (recursive ? (string) "r:" : "") +
  141. printHashType(hashAlgo) + ":" + printHash(hash) + ":"),
  142. name);
  143. }
  144. Path computeStorePathForText(const string & name, const string & s,
  145. const PathSet & references)
  146. {
  147. Hash hash = hashString(htSHA256, s);
  148. /* Stuff the references (if any) into the type. This is a bit
  149. hacky, but we can't put them in `s' since that would be
  150. ambiguous. */
  151. string type = "text";
  152. foreach (PathSet::const_iterator, i, references) {
  153. type += ":";
  154. type += *i;
  155. }
  156. return makeStorePath(type, hash, name);
  157. }
  158. /* Return a string accepted by decodeValidPathInfo() that
  159. registers the specified paths as valid. Note: it's the
  160. responsibility of the caller to provide a closure. */
  161. string StoreAPI::makeValidityRegistration(const PathSet & paths,
  162. bool showDerivers, bool showHash)
  163. {
  164. string s = "";
  165. foreach (PathSet::iterator, i, paths) {
  166. s += *i + "\n";
  167. ValidPathInfo info = queryPathInfo(*i);
  168. if (showHash) {
  169. s += printHash(info.hash) + "\n";
  170. s += (format("%1%\n") % info.narSize).str();
  171. }
  172. Path deriver = showDerivers ? info.deriver : "";
  173. s += deriver + "\n";
  174. s += (format("%1%\n") % info.references.size()).str();
  175. foreach (PathSet::iterator, j, info.references)
  176. s += *j + "\n";
  177. }
  178. return s;
  179. }
  180. string showPaths(const PathSet & paths)
  181. {
  182. string s;
  183. foreach (PathSet::const_iterator, i, paths) {
  184. if (s.size() != 0) s += ", ";
  185. s += "`" + *i + "'";
  186. }
  187. return s;
  188. }
  189. void exportPaths(StoreAPI & store, const Paths & paths,
  190. bool sign, Sink & sink)
  191. {
  192. foreach (Paths::const_iterator, i, paths) {
  193. writeInt(1, sink);
  194. store.exportPath(*i, sign, sink);
  195. }
  196. writeInt(0, sink);
  197. }
  198. Path readStorePath(Source & from)
  199. {
  200. Path path = readString(from);
  201. assertStorePath(path);
  202. return path;
  203. }
  204. template<class T> T readStorePaths(Source & from)
  205. {
  206. T paths = readStrings<T>(from);
  207. foreach (typename T::iterator, i, paths) assertStorePath(*i);
  208. return paths;
  209. }
  210. template PathSet readStorePaths(Source & from);
  211. }
  212. #include "local-store.hh"
  213. #include "serialise.hh"
  214. namespace nix {
  215. std::shared_ptr<StoreAPI> store;
  216. std::shared_ptr<StoreAPI> openStore(bool reserveSpace)
  217. {
  218. return std::shared_ptr<StoreAPI>(new LocalStore(reserveSpace));
  219. }
  220. }