toad.social

4 posts2 participants0 posts today

Karl BaronIt looks like CW by default auto-includes any Mac headers you need, but at the same time stdlib stuff like "strlen" isn't working even with a manual <a href="https://bitbang.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <strings.h> which is the point where I'm starting to look at "maybe I should read a book instead of just poking at things randomly!" (2/2)

Jann Horn<a href="https://infosec.exchange/@jduck" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@jduck</a> I mean, if it convinces you...<pre><code>$ cat blub.c #include <stdlib.h> #include <stdio.h> struct foo { long a; int b; int arr[]; }; int main(void) { struct foo *a = malloc(sizeof(struct foo) + sizeof(int)*3); struct foo *b = malloc(sizeof(struct foo) + sizeof(int)*3); if (!a || !b) return 1; a->a = 1; a->b = 2; for (int i=0; i<3; i++) a->arr[i] = i + 123456; b->a = 101; b->b = 102; for (int i=0; i<3; i++) b->arr[i] = i + 100; *b = *a; for (int i=0; i<3; i++) printf("%d ", b->arr[i]); printf("\n"); } $ gcc -o blub blub.c $ ./blub 123456 101 102 </code></pre>

Jann HornWhy does the C standard not mention any UB in its definition of offsetof()? Is it implicit somewhere else that doing <code>offsetof(struct foo, arr[SIZE_MAX])</code> on a struct containing a flexible array member is UB?Both GCC and clang don't diagnose anything here and compile it to a "return 0":<pre><code>#include <stddef.h> #include <inttypes.h> struct foo { int a; int arr[]; }; unsigned long func(void) { return offsetof(struct foo, arr[SIZE_MAX]); } </code></pre><a href="https://godbolt.org/z/rx7rqvh7j" rel="nofollow noopener noreferrer" translate="no" target="_blank">https://godbolt.org/z/rx7rqvh7j</a>

Jann HornFunny standard C behavior - assigning a struct with flexible array member can copy parts of the flexible array member:<pre><code>$ cat vla_assign.c #include <stdlib.h> #include <stdio.h> struct foo { long a; int b; int arr[]; }; int main(void) { struct foo *a = malloc(sizeof(struct foo) + sizeof(int)*3); struct foo *b = malloc(sizeof(struct foo) + sizeof(int)*3); if (!a || !b) return 1; a->a = 1; a->b = 2; for (int i=0; i<3; i++) a->arr[i] = i; b->a = 101; b->b = 102; for (int i=0; i<3; i++) b->arr[i] = i + 100; *b = *a; for (int i=0; i<3; i++) printf("%d ", b->arr[i]); printf("\n"); } $ gcc -Wall -Wextra -pedantic -o vla_assign vla_assign.c $ ./vla_assign 0 101 102 </code></pre>

russell<a href="https://mastodon.social/@whitequark" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@whitequark</a> <a href="https://chaos.social/@ronya" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@ronya</a> That is wild because the whole reason for that separate parser is to be able to reindex individual files without paying attention to the <a href="https://mastodon.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> graph or anything.It doesn't do this for me, but that's using "full" VS, which shares the parser(s) but not the layer that orchestrates them. (But also both VS and Code are prone to behaving in similarly broken ways.)

Simon Zerafa<a href="https://mastodon.social/@Wileymiller" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@Wileymiller</a> <a href="https://infosec.exchange/tags/Include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#Include</a>

Shafik YaghmourRetro C++ quiz #26<a href="https://hachyderm.io/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <cmath>auto f(unsigned int x) { return std::abs(x); // Well-formed? }Without checking:A. Yes B. No C: Show answers<a href="https://hachyderm.io/tags/cplusplus" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#cplusplus</a> <a href="https://hachyderm.io/tags/Cpppolls" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#Cpppolls</a>

Jann Hornfun Linux fact: because <code>MAP_SHARED|MAP_ANONYMOUS</code> is actually a file-backed mapping under the hood, unmapping part of such a mapping does not discard the data stored in that part:<pre><code>$ cat mremap.c #define _GNU_SOURCE #include <err.h> #include <stdio.h> #include <sys/mman.h> int main(void) { char *p = mmap(NULL, 0x2000, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0); if (p == MAP_FAILED) err(1, "mmap"); p[0x1000] = 'X'; if (munmap(p+0x1000, 0x1000)) err(1, "munmap"); // that 'X' we just wrote... is it gone? // nope, let's bring it back! p = mremap(p, 0x1000, 0x2000, MREMAP_MAYMOVE); if (p == MAP_FAILED) err(1, "mremap"); printf("p[0x1000]='%c'\n", p[0x1000]); } $ gcc -o mremap mremap.c $ ./mremap p[0x1000]='X' $ </code></pre>

prozacchiwawaok i hit this weekend's goal:<a href="https://functional.cafe/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <windows.h>int main(int argc, char **argv) { char computer_name_buf[1024]; DWORD buf_size = sizeof(computer_name_buf); GetComputerNameA(computer_name_buf, &buf_size); printf("hi from main: computer name %s\n", computer_name_buf); return 0; }

Björkus "No time_t to Die" DorkusTime to get printf to the SIZE_MAX off the ground. Especially since it's not the type that matters for the precision specifier for the string size, it's the actual value.<pre><code>#include <stdio.h> #include <stdlib.h> #include <limits.h> #include <assert.h> int main() { enum { COUNT = 10, BYTESIZE = INT_MAX / COUNT }; char* str = (char*)malloc(BYTESIZE + 1); for (size_t i = 0; i < BYTESIZE; ++i) { str[i] = 'a'; } str[BYTESIZE] = '\0'; FILE* f = fopen("/dev/null", "w+"); [[maybe_unused]] int write_value = fprintf(f, "%.*s", BYTESIZE, str); [[maybe_unused]] int large_write_value = fprintf(f, "%.*s %*.s %*.s %*.s %*.s %*.s %*.s %*.s %*.s %*.s %*.s", BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str, BYTESIZE, str); free(str); assert(write_value == BYTESIZE); // Well. assert(large_write_value == -1); // ... Okay. // this should let the other thing work out nicely, then. return 0; } </code></pre>

Gareth Lloyd (He/him)Did you extract anything into a function? Did you give it a good name?Have a look in `<a href="https://fosstodon.org/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <algorithm>` does it already exist?<a href="https://en.cppreference.com/w/cpp/algorithm" rel="nofollow noopener noreferrer" translate="no" target="_blank">https://en.cppreference.com/w/cpp/algorithm</a>

Jann HornWow, <a href="https://clang.llvm.org/docs/LanguageExtensions.html#builtin-dump-struct" rel="nofollow noopener noreferrer" target="_blank"><code>__builtin_dump_struct</code></a> is an amazing clang feature, how did I never hear about this before?<pre><code>$ cat test.c #include <stdio.h> struct nested { int n; }; struct foo { int member_a; unsigned long member_b; char *str; void *ptr; struct nested nested; }; int main(void) { struct foo f = { .member_a = 123, .member_b = 0x4141414141414141, .str = "foobar", .ptr = &f, .nested = {.n = 42} }; __builtin_dump_struct(&f, printf); } $ clang -o test test.c && ./test struct foo { int member_a = 123 unsigned long member_b = 4702111234474983745 char * str = "foobar" void * ptr = 0x7fff1df41b78 struct nested nested = { int n = 42 } } </code></pre>The <a href="https://github.com/llvm/llvm-project/commit/0652534131b269eec336a2ed3545642cc01a1300" rel="nofollow noopener noreferrer" target="_blank">original version</a> of this feature was introduced back in 2018 (though it was <a href="https://github.com/llvm/llvm-project/commit/c4f95ef86a224fe730d2219aab90e88a0e7b03d2" rel="nofollow noopener noreferrer" target="_blank">reimplemented since</a> in 2022).

Karsten Johansson<a href="https://mastodon.sdf.org/@screwtape" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@screwtape</a> <a href="https://mstdn.social/@praetor" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@praetor</a> <a href="https://infosec.exchange/@untakenusername" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@untakenusername</a> <a href="https://infosec.exchange/@bughuntercat" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@bughuntercat</a> Just to beat the hell out of a dead horse (this one took longer):C: <a href="https://infosec.exchange/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <a href="https://infosec.exchange/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> int main() { int* arr = malloc(5 * sizeof(int)); if (!arr) return 1; // Check allocation success for (int i = 0; i < 5; i++) { arr[i] = i * 10; } for (int i = 0; i < 5; i++) { printf("%d ", arr[i]); } free(arr); return 0; }Common Lisp: (loop for i from 0 below 5 collect (* i 10) into arr finally (print arr))Which language does low level things easier? Clearly Common Lisp does... (even if this is high level representation of low level things...) :ablobcatrave:

Karsten Johansson<a href="https://mastodon.sdf.org/@screwtape" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@screwtape</a> <a href="https://mstdn.social/@praetor" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@praetor</a> <a href="https://infosec.exchange/@untakenusername" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@untakenusername</a> <a href="https://infosec.exchange/@bughuntercat" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@bughuntercat</a> This deserves an example.C: <a href="https://infosec.exchange/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <a href="https://infosec.exchange/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> int main() { uint8_t x = 0xA5; // Extract the high nibble: shift right by 4 bits then mask uint8_t high_nibble = (x >> 4) & 0x0F; printf("High nibble: %X\n", high_nibble); return 0; }Common Lisp: (let ((x <a href="https://infosec.exchange/tags/xA5" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#xA5</a>)) (format t "High nibble: ~X~%" (ldb (byte 4 4) x)))This is how I started using <a href="https://infosec.exchange/tags/lisp" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#lisp</a> from the very early days. So I see it as an easier way to do low level things. The rest (OOP and all) are things pretty much all modern languages do easily.I recently found one of my first very low level Lisp programs. I'll post it one day. It is ethically questionable though, because it outputs DOS-based viruses lol.

mccIf you want me to hate you forever, a good way to do this is to share sample code as a isolated function in a blockquote, which produces a dozen 'symbol not found' errors when punched into actual code because you *didn't* include a blockquote containing the half-dozen <a href="https://mastodon.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> or `using` or `import` statements that would be needed to bring the various API calls and types you reference into scope

phase separation anxiolyte<a href="https://infosec.exchange/@atax1a" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@atax1a</a> right. <a href="https://mastodon.mit.edu/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <stdio.h> probably 2

Taxo Rubio:wq<a href="https://chaos.social/@root42" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@root42</a> <a href="https://social.tchncs.de/@cgudrian" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@cgudrian</a> Checking it out now, I just got bitten by integer promotion rules again. Rip.The i/j example still yields 255:(gdb) l 1 <a href="https://fosstodon.org/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <cstdint> 2 3 int main () { 4 uint8_t i = 0; 5 uint8_t j = (i-1) % 128; 6 } (gdb) br 6 Breakpoint 1 at 0x113c: file a.cpp, line 6. (gdb) r Starting program: /home/groctel/a.out Breakpoint 1, main () at a.cpp:6 6 } (gdb) p i $1 = 0 '\000' (gdb) p j $2 = 255 '\377'

root42<a href="https://social.tchncs.de/@cgudrian" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@cgudrian</a> Casts seem to handle correctly. I tried this one: <a href="https://chaos.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <stdio.h> <a href="https://chaos.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <stdint.h>int main(void) { unsigned int i = 65535; uint8_t j = (uint8_t)i; printf("%u %u\n", i, j); i--; j = (uint8_t)i; printf("%u %u\n", i, j); return 0; }Which leads the correct results, just as clang

root42<a href="https://social.tchncs.de/@cgudrian" class="u-url mention" rel="nofollow noopener noreferrer" target="_blank">@cgudrian</a> My test program looks like this now: <a href="https://chaos.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <stdint.h> <a href="https://chaos.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <stdio.h>int main(void) { for(int i = 0; i < 3; i++) { uint8_t c1 = (i - 1) & 255; uint8_t c2 = i - 1; printf("%u %u\n", c1, c2); } return 0; } And it produces the "correct" result with bit masking, and is faulty without.

root42To my <a href="https://chaos.social/tags/c" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#c</a> and <a href="https://chaos.social/tags/cxx" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#cxx</a> <a href="https://chaos.social/tags/cpp" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#cpp</a> bubble: Why does a uint8_t get promoted to uint when doing -1 on it? Example:<a href="https://chaos.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <stdio.h> <a href="https://chaos.social/tags/include" class="mention hashtag" rel="nofollow noopener noreferrer" target="_blank">#include</a> <stdint.h>int main(void) { uint8_t c1 = 0; printf("%u\n", c-1); return 0; }This will print (uint8_t)(c1-1) if you don't cast: (uint8_t)(c1-1)

Recent searches

Search options

Administered by:

Server stats:

#include