Sane | Python interface to the SANE scanner and frame grabber

Is the above code invoking undefined behaviour?

Yes, you've broken Rust's pointer aliasing rules. Relying on the Stacked Borrows rules is a bit dubious since, as you've hinted, I don't think it has been officially adopted as Rust's memory access model (even if it was just a formalization on the current semantics). However, something that is a practical and concrete ruling is LLVM's noalias attribute, which the Rust compiler uses on &mut arguments.

noalias

This indicates that memory locations accessed via pointer values based on the argument or return value are not also accessed, during the execution of the function, via pointer values not based on the argument or return value. ...

So since you access ints[1] in another_rust_function from a pointer that is not based based on the ints in first_rust_function during the execution of that function, it is a violation. In light of this undefined behavior, I believe the compiler is well within its rights to make the code print "Second value: 4".

Would the behaviour be well-defined if called_from_rust() would have the pointer as parameter and pass it forward: void called_from_rust(const int * i) { another_rust_function(i); }?

Yes, that will make it well defined. You can see that because the Rust borrow checker can then see that the value can be used in called_from_rust() and will prevent improper use of ints around that call.

What if both Rust functions were using &mut [c_int;3]?

If you used the fix above, where the second borrow is based on the first, then there's no problem. If you didn't though, then it is way worse.

Consider using a named list. Is this what you want?

You can think of this as defense in depth, an additional layer of protection against generic threats around file uploads.

One that directly comes to mind is an attacker uploading many very small (or 0 byte) files. Those would normally get stored in the temp directory (/tmp usually), and on many filesystems there is limit to the number of files in a directory, and a lot of files can also affect filesystem performance.

This is a risk you can decide to accept, or implement other mitigations so this php setting doesn't "get in the way". Quite honestly, in many applications this would likely never cause an issue, but you need to be aware and make an informed decision. In some higher security applications increasing or removing this limitation might not be acceptable.

The error unknown global field 'passphrase must be 8..63 characters' is confusing.

If the passphrase is correct, then I think some configuration file consists of exactly the same string passphrase must be 8..63 characters instead of some useful value and hence the error unknown global field 'passphrase must be 8..63 characters.

You can search and validate the same using grep -rn "characters" /etc/ and remove the string from the configuration file that contains passphrase must be 8..63 characters.

I had the same problem with literally the exact same number of vulnerabilities.

Check out the solution here

Yes, it is sound. In fact, the official documentation for transmute() says it can be used to extend lifetimes:

https://doc.rust-lang.org/stable/std/mem/fn.transmute.html#examples

Extending a lifetime, or shortening an invariant lifetime. This is advanced, very unsafe Rust!

For this answer, I'll assume you have correctly understood the reasons why you should and should not do Hive-style partitioning and won't be covering the backing theory.

In this case, it's important to ensure we not only correctly calculate the number of files needed inside our splits but also repartition our dataset based on these calculations. Failure to do repartitions before write-out on Hive-style partition datasets may result in your job attempting to write out millions of tiny files which will kill your performance.

In our case, the strategy we will use will be to create files that are at most N rows per file, which will bound the size of each file. We can't easily limit the exact size of each file inside the splits, but we can use row counts as a good approximation.

The methodology we will use to accomplish this will be to create a synthetic column that describes which 'batch' a row will belong to, repartition the final dataset on both the Hive split column and this synthetic column, and use this result on write.

In order to ensure our synthetic column indicates the proper batch a row belongs to, we need to determine the number of rows inside each hive split, and 'sprinkle' the rows inside this split into the proper number of files.

The strategy in total will look something like this:

1. Determine number of rows per Hive value
2. Join this count against main dataframe
3. Determine number of files in split by dividing row count per split by rows per file
4. Create random index between 0 and the file count, essentially 'picking' the file the row will belong to
5. Calculate number of unique combinations of Hive split columns and our synthetic column
6. Repartition output dataset over both Hive column and synthetic column into the number of unique combinations. i.e. one file per combination, exactly what we want

Let's start by considering the following dataset:

I think your pod install working fine and has done its job. You need to set up iPhone SDK on your mac then try to run cd ../ && react-native run-ios.

Follow this guide : React Native Environment set up on Mac OS with Xcode and Android Studio

This C11 Draft Standard suggests that, while not part of the core standard, casting function pointers to object pointers (for purposes of testing, as in your NULL-check) falls under the category of "Common Extensions" (Annex J.5):

J.5.7 Function pointer casts

1     A pointer to an object or to void may be cast to a pointer to a function, allowing data to be invoked as a function (6.5.4).

2     A pointer to a function may be cast to a pointer to an object or to void, allowing a function to be inspected or modified (for example, by a debugger) (6.5.4)