How about a new lint instead?
304 karma · joined February 21, 2022
How about a new lint instead?
> * If a signal handler interrupts the execution of an unsafe function, and the handler terminates via a call to longjmp(3) or siglongjmp(3) and the program subsequently calls an unsafe function, then the behavior of the program is undefined.
Also note that pthread_cancel() provides a way to block asynchronous cancellations via pthread_setcancelstate().
Of course UNION [ALL] does often yield better performance, yes.
aka "totally unknown environment" which you "need feedback about what works and what doesn’t"
Disclaimer: I concur that this is merely a workaround, not the real fix
Nothing in particular.
> Also, why should I not be here? You have any problem with it?
Not at all.
You might be reading too much into my comment, though.
Why are you here, though?
If OP went along the "father, son, and donkey story," then the OP won't have posted it at all.
I was talking about if long period of "high" can be distinguished from long period of "low"--DC offsets.
That means bash has applications (e.g., batch processing and file management) that JS can't be (easily) used for. And they never said bash is bad at them. That...proves my point?
The paradigm is called point-free programming[1], right? I don't know how "imperative" is relevant here--you can rewrite most of the coreutils in Haskell, for example.
If the answer is "no," that means JS has applications (e.g., servers and web clients) that bash can't be used for. And they're saying JavaScript is bad at them. Bash is arguably worse, but it's usually not an option in the first place so you don't get to complain.
It's worth noting that UAC is not a security boundary[1]. Sure, a safeguard mechanism, but not a security feature against stealth rootkits trying to escalate from non-privileged environment.
[1]: https://security.stackexchange.com/questions/189491/microsof...
One question: how do you detect when a binary is intentionally made to statically look similar to one binary, while its behavior actually mimics another?
Products can only do best effort scanning for known patterns of vulnerabilites. Those are only added after someone (or something) discovers it and verifies that it's not a false alarm. In between the time gap, scanners are ineffective and anything in your infrastructure can run the malicious code and get hacked. (Google supply chain incidents on npm or pypi.)
In general, there is always a way to bypass it, since the language is turing complete and unsandboxed. Anything going beyond that is a lie, or simply impractical. Systems with latest software and antivirus get hacked all the time. Nothing can really stop them. Why?
- https://web.archive.org/web/20160424133617/http://www.pcworl...
- https://security.stackexchange.com/questions/201992/has-it-b...
- https://en.wikipedia.org/wiki/Rice%27s_theorem
> and either block them from entering the network or fail CI pipelines.
Also, relying solely on an endpoint security product for protection is dangerous since antiviruses themselves get hacked all the time. Sonatype for an example:
- https://nvd.nist.gov/vuln/search/results?form_type=Basic&res...
> call 1f > > 1: <next instruction>
It's worth noting that "call $+5" degrades performance if used improperly. Consider:
call 1f
1:
pop %eax
See the problem? (Hint: it's branch prediction)That's right! The CPU has its own idea of an approximate "call stack" (a.k.a. return stack buffer), which it uses to predict branch target for RETs.
Note that the POP doesn't count as a "return," so it usually does not pop from the return stack buffer at all. In this case, the CPU confidently mispredicts the branch when the next matching RET gets queued into the pipeline, sometimes severly degrading performance.
On Linux there's a stub subroutine that does exactly that: __i686.get_pc_thunk.<reg>.
Here's the entire subroutine:
__i686.get_pc_thunk.bx:
MOV EBX, DWORD PTR [ESP]
RET
Yup, that's all. If you compile with gcc -m32 -fPIC, you'll see a call to that thunk whenever a function accesses GOT or other relocatable symbols. #define FLAG_63 (1ULL << 63)
long long flags = FLAG_63;
In this case, if (flags & FLAG_63) pass();
will pass, but typedef int BOOL;
BOOL set = flags & FLAG_63;
if (set) pass();
won't pass, due to truncation.Question: Would you argue that a datatype that holds the smallest (1-bit) datum should be as wide as the largest integer type just to handle such cases?
If so, that would be highly inefficient for storage purposes. Note that Win32 has 32-bit BOOL type, but internally NT uses 8-bit BOOLEAN type to store bools in structures.
To override the character for "EOF," change ^D to something else in the following command and run it:
stty eof ^D