LDD | Code and scripts for LDD and Renderman

Alpine makes use of musl which is a minimalistic libc. My guess is that your binary is using non-standard functions that do not exist under Alpine.

I see two solutions to that :

• Try to install glibc in your docker container
• Probably the easiest solution : try to find a Docker image that uses it as default (a minimalistic Debian/Ubuntu Docker should do it)

Issue solved.

I created a custom Vault image and in the Dockerfile I made it to include all the dependencies

Lua can be compiled both as C ans C++ languages. This is an advertised feature of it. For that reason, Lua authors decided not to include the classic extern "C" in the headers.

Your liblua5.2.so.5.2 library was compiled in C language and the symbols are not mangled. You compiled your application in C++ mode with just including Lua headers without extern "C", so your Lua included symbols are mangled.

Solution: wrap your include with extern "C":

I don't have an easy access to a Linux where I can test it, but I think I now understand what's happening.

1. matplotlibcpp uses a static variable to hold the Python interpreter (see line 129 inside interkeeper(bool should_kill)). Like C++ static function variables, it's initialized on the first time the function is called and destructed on program's exit (reference).

2. When main finishes, libc runs cleanup routines for all the shared libraries and for your program (that's __run_exit_handlers in the stacktrace). Since your program is a C++ program, part of its exit handler is destructing all the static variables that were used. One of them is the Python interpreter. Its destructor calls Py_Finalize() which is Python's cleanup routine. Until now, everything's fine.

3. Python has a similar atexit mechanism that allows Python code from everywhere to register functions that should be called during the interpreter shutdown. Apparently, the backend matplotlib chose to use here is PyQt5. It seems to register such atexit callbacks.

4. PyQt5's callback gets called, and crashes. Notice that this is internal PyQt5 code now. Why does this crash? My "educated" guess is that Qt's library exit handler was already called in step 2, before your program's exit handler was called. This apparently causes some weird state in the library (maybe some objects were freed?) and crashes.

This leaves two interesting questions:

1. How to fix this? The solution should be to destruct ctx before your program exits, so the Python interpreter is destructed before any shared libraries terminate themselves. Static lifetimes are known for causing similar problems. If changing matplotlibcpp's interface to not use global static states is not a possible solution, I think you really have to manually call plt::detail::_interpreter::kill() at the end of your main function. You should be able to use atexit() and register a callback that kills the interpreter before the library teardown - I haven't tested it though.

2. Why did this ever work? My guess is that maybe something in PyQt5's callbacks has changed that now causes this crash, or that you use a different backend in Python 2. If no other library is destructively terminating before the program exits, this is fine.

When calculating the hash of the to-be-signed attributes, you use the then current time as value of the signing time attribute:

You need to create table in sqlite database. Mention columns whatever you require while creating the table.

While inserting the data, you need to use the column names of Table.

For more details follow this tutorial https://likegeeks.com/python-sqlite3-tutorial/.

There's a difference between the link-time path to a library and the run-time path.

Since the library is in a location that (apparently) isn't handled by the run-time loader you must add a flag when linking to tell the linker to add information about it in the executable for the run-time loader to check.

This is done with the -rpath linker specific flag.

You can pass it using gcc with the -Wl option:

This can happen if the page is in the process of shifting around as it is re-rendered. An explicit wait can help solve the problem:

Yes, this will work as long as as libfoo does not intercept any function already intercepted by Asan (you can get full list from readelf -sW --dyn-syms $(gcc -print-file-name=libasan.so)). To be safe Asan will emit a warning in that case which you can suppress via ASAN_OPTIONS=verify_asan_link_order=0.