Marek Niepiekło niepiekm

Downloading older versions of iOS apps using ipatool

👉 ipatool is an open-source tool developed by Majd, a highly trustworthy and talented developer in the iOS community. Recently, ipatool got a significant update that allows users to easily download older versions of iOS apps on macOS/Windows/Linux!.

👉 Since ipatool doesn't have a graphical user interface (GUI), some of you might think it's tricky to use. But trust me, it's not! Here's a simple guide if you're still a bit scared of the terminal. (Tbh, everything in this *guide can be found on ipatool's repo)

👉 Note: You need to log into your Apple ID via ipatool for the tool to work. Unless you prioritize security above all, you can trust logging into your Apple account with ipatool. As explained earlier, it’s an open-source tool developed by a well-known and reliable developer, minimizing security risks to the lowest level.

Mutexes vs. Atomics in C++: Memory Orders, How They Work at a Lower Level, and When to Use Each

Disclaimer: ChatGPT generated document.

Concurrency in C++ requires proper synchronization to avoid data races. Mutexes and atomics provide two different approaches for thread synchronization. Understanding their internal mechanics and memory ordering is essential for writing efficient multi-threaded applications.

Why did you do this?

Relax, I only have one Sunday to work on idea, literally my weekend project. So I tried Deepseek to see if it can help. Surprisingly, it works and it saves me another weekend...

What is your setup?

Just chat.deepseek.com (cost = free) with prompts adapted from this gist.

Does it work in one-shot or I have to prompt it multiple times?

This is from man bash:

A pipeline is a sequence of one or more commands separated by one of the control operators | or |&. The format for a pipeline is:

[ time [ -p ]] [ ! ] command [ [ | | |& ] command2 ... ]

This is the only place in which ! can appear. It never prefixes commands, it prefixes pipelines.

A Short IPv6 Guide for Home IPv4 Admins

This guide is for homelab admins who understand IPv4s well but find setting up IPv6 hard or annoying because things work differently. In some ways, managing an IPv6 network can be simpler than IPv4, one just needs to learn some new concepts and discard some old ones.

Let’s begin.

First of all, there are some concepts that one must unlearn from ipv4:

Concept 1

FAQ on the xz-utils backdoor (CVE-2024-3094)

This is a living document. Everything in this document is made in good faith of being accurate, but like I just said; we don't yet know everything about what's going on.

Update: I've disabled comments as of 2025-01-26 to avoid everyone having notifications for something a year on if someone wants to suggest a correction. Folks are free to email to suggest corrections still, of course.

Background

Debugging apps (inspect)

Inspectability

Developer mode apps (those installed in /media/developer) are inspectable by default. Other apps (e.g., from the LG Content Store) are not inspectable by default, but you can add "inspectable": true to their appinfo.json to enable it. Debugging system apps (i.e., those in /usr/palm/applications) may require a special flag.

Ports

The developer mode app debugger listens on port 9998.

System service and system app debugging uses ports 5885 and 9999, respectively. However, debugging for these is not normally enabled.

Inspecting an app

C/C++ performance pitfall: int8_t, aliasing and the ways out

When I was working on a generic port of Google's hashmap to C, I wrote a function that (ignoring irrelevant parts) looked like this:

typedef struct {
    uint8_t *bytes;
    size_t len;
} bytebuf;

	// defer.h
	// [email protected]
	// © 2025 Crash Override, Inc.
	// Licensed under the BSD 3-Clause license

	#pragma once
	#include <stdint.h>

	typedef struct n00b_defer_ll_t n00b_defer_ll_t;

	// Background: https://www.snellman.net/blog/archive/2016-12-13-ring-buffers/
	// Variant with indices modulo 2*capacity as suggested by dizzy57 and Aristotle Pagaltzis

	size_t read;
	size_t write;

	mask(val) { return val % array.capacity; }
	inc(index) { return wrap(index + 1); }
	push(val) { assert(!full()); array[mask(write)] = val; write = inc(write); }
	shift() { assert(!empty()); ret = array[mask(read)]; read = inc(read); return ret; }