文章目录
  1. 1. 按顺序构造『虚拟的』 Hook 链表
  2. 2. 撤销 Hook
  3. 3. 总结

BlockHook 开创性地解决了 Objective-C 语言界 Hook Block 的问题,但也迎来了新的问题:

  1. 如何知道某个 Block 对象被谁 Hook 过?
  2. 多次 Hook 的先后顺序?
  3. 如何处理好多次 Hook 同一个 Block 后对任意一次 Hook 的撤销?

这些问题也是开发者在使用时向我反馈过的问题,在这篇文章里,这些问题都将会解决。

关于 BlockHook 的原理,可以先阅读之前的文章:

按顺序构造『虚拟的』 Hook 链表

首先要有一个链表来按先后顺序记录一个 Block 对象上所有的 Hook。这个链表的格式以及持有关系也需要考虑在内。

为此我构造了一个虚拟的链表来记录 Hook 的先后关系,而不是单独创建一个链表显式的记录。首先介绍下 Block 与 token 之间的引用关系:

可以看出每个 BHToken 记录了原始和替换后的 invoke 函数指针,那么先后两次 Hook 就靠 invoke 函数指针来关联了:每个 tokne 的 originalInvoke 就是上一次 Hook 的 token 的 replacementInvoke。而拿到 token 又是靠 Block 对象上的 AssociatedObject,且 key 为 replacementInvoke。这样就构造了一条虚拟的链表:想要获得上次 Hook 的 token,只需在 Hook 的 Block 对象上使用 originalInvoke 作为 key 即可。

下面的代码展示了获取下个 token 的 next 实现。因为链表可能会有新的插入和删除节点操作,所以需确保线程安全。

1
2
3
4
5
6
7
8
9
10
11
- (BHToken *)next
{
BHLock *lock = [self.block bh_lockForKey:@selector(next)];
[lock lock];

if (!_next) {
_next = objc_getAssociatedObject(self.block, self.originInvoke);
}

BHToken *result = _next;
[lock unlock];
return result;
}

这里使用 replacementInvoke 来作为 AssociatedObject 的 key 真是一举多得

  1. 将 token 的生命周期绑定到 Block 对象上,实现 self-managed
  2. 因为函数指针地址是唯一的,确保 Block 上关联每个 token 的 key 不会冲突
  3. Block 的 invoke 指针作为 key,可以找到最后一次 Hook 的 token。进而按 Hook 先后顺序遍历出所有的 token。

下面的代码展示了如何获取最后一次 Hook 的 token。在读取 invoke 函数指针的时候,注意保证线程安全。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
- (BHToken *)block_currentHookToken
{

if (![self block_checkValid]) {
return nil;
}
void *invoke = [self block_currentInvokeFunction];
return objc_getAssociatedObject(self, invoke);

}

- (void *)block_currentInvokeFunction
{

struct _BHBlock *bh_block = (__bridge void *)self;
BHLock *lock = [self bh_lockForKey:_cmd];
[lock lock];

void *invoke = bh_block->invoke;
[lock unlock];

return invoke;
}

撤销 Hook

俗话说『请神容易送神难』。好多 Hook 框架只解决的如何 Hook,但是却无法撤销恢复原样,留下一堆烂摊子。

在搭建了 Hook 链表的基础上,多次 Hook 的链表可以简化成 invoke 函数指针之间的关系:

那么撤销 Hook 就可以从链表头部开始遍历,找到当前要 remove 的 token。接着链表上删除这个 token,而这又可以分为两个子问题:

  1. 移除最后一次 Hook:需要将 Block 的 invoke 指针指向 token 的 originalInvoke
  2. 移除最后一次 Hook:需要将上一次 Hook token 的 originalInvoke 指向当前 token 的 originalInvoke

最后肯定还要解除 Block 对象对 token 的持有。

这部分逻辑的实现代码如下,在操作 Block 的 invoke 指针时依然需要注意线程安全问题:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
- (BOOL)remove
{
if (self.isStackBlock) {
NSLog(@"Can't remove token for StackBlock!");
return NO;
}
self.deadBlock = nil;
if (self.originInvoke) {
if (self.block) {
BHToken *current = [self.block block_currentHookToken];
BHToken *last = nil;
while (current) {
if (current == self) {
if (last) { // remove middle token
last.originInvoke = self.originInvoke;
last.next = nil;
}
else { // remove head(current) token
BHLock *lock = [self.block bh_lockForKey:@selector(block_currentInvokeFunction)];
[lock lock];
((__bridge struct _BHBlock *)self.block)->invoke = self.originInvoke;
[lock unlock];
}
break;
}
last = current;
current = [current next];
}
}
self.originInvoke = NULL;
objc_setAssociatedObject(self.block, _replacementInvoke, nil, OBJC_ASSOCIATION_RETAIN);
return YES;
}
return NO;
}

总结

这也竟然能水一篇,哈哈。

文章目录
  1. 1. 按顺序构造『虚拟的』 Hook 链表
  2. 2. 撤销 Hook
  3. 3. 总结