feat: add server-side binder protocol constants, TransactionReceiver interface, and local binder parcel support

Author: xaionaro@dx.center

binder/transaction_receiver.go

@@ -0,0 +1,18 @@
+package binder
+
+import (
+	"context"
+
+	"github.com/xaionaro-go/binder/parcel"
+)
+
+// TransactionReceiver processes incoming binder transactions.
+// Implemented by generated Stub types that dispatch transaction
+// codes to typed Go interface methods.
+type TransactionReceiver interface {
+	OnTransaction(
+		ctx context.Context,
+		code TransactionCode,
+		data *parcel.Parcel,
+	) (*parcel.Parcel, error)
+}

kernelbinder/protocol.go

@@ -7,20 +7,27 @@ import "unsafe"
 // Binder command (BC) codes -- written to the driver.
 // Codes that carry a struct payload encode sizeof(payload) in the ioctl-style
 // number, so they must be computed from the actual Go struct sizes.
-//
-// Only currently-used codes are defined here. The full protocol is documented
-// in the design doc and additional codes can be added as features are implemented.
 var (
 	bcTransaction       = uint32(iow('c', 0, unsafe.Sizeof(binderTransactionData{})))
+	bcReply             = uint32(iow('c', 1, unsafe.Sizeof(binderTransactionData{})))
 	bcFreeBuffer        = uint32(iow('c', 3, unsafe.Sizeof(uintptr(0)))) // binder_uintptr_t
 	bcIncRefs           = uint32(iow('c', 4, unsafe.Sizeof(uint32(0))))
 	bcAcquire           = uint32(iow('c', 5, unsafe.Sizeof(uint32(0))))
 	bcRelease           = uint32(iow('c', 6, unsafe.Sizeof(uint32(0))))
 	bcDecRefs           = uint32(iow('c', 7, unsafe.Sizeof(uint32(0))))
+	bcIncRefsDone       = uint32(iow('c', 8, binderPtrCookieSize))
+	bcAcquireDone       = uint32(iow('c', 9, binderPtrCookieSize))
+	bcRegisterLooper    = uint32(ioc(0, 'c', 11, 0))
+	bcEnterLooper       = uint32(ioc(0, 'c', 12, 0))
+	bcExitLooper        = uint32(ioc(0, 'c', 13, 0))
 	bcRequestDeathNotif = uint32(iow('c', 14, binderHandleCookieSize))
 	bcClearDeathNotif   = uint32(iow('c', 15, binderHandleCookieSize))
 )
 
+// binderPtrCookieSize is the size of the kernel's binder_ptr_cookie struct:
+// binder_uintptr_t ptr + binder_uintptr_t cookie (2 x pointer-sized).
+const binderPtrCookieSize = 2 * unsafe.Sizeof(uintptr(0)) // = 16 on 64-bit
+
 // binderHandleCookieSize is the packed size of the kernel's binder_handle_cookie
 // struct: __u32 handle + binder_uintptr_t cookie. The kernel struct uses
 // __attribute__((packed)), so there is NO alignment padding between fields.
@@ -29,9 +36,14 @@ const binderHandleCookieSize = unsafe.Sizeof(uint32(0)) + unsafe.Sizeof(uintptr(
 // Binder return (BR) codes -- read from the driver.
 var (
 	brError               = uint32(ior('r', 0, unsafe.Sizeof(int32(0))))
+	brTransaction         = uint32(ior('r', 2, unsafe.Sizeof(binderTransactionData{})))
 	brReply               = uint32(ior('r', 3, unsafe.Sizeof(binderTransactionData{})))
 	brDeadReply           = uint32(ioc(0, 'r', 5, 0))
 	brTransactionComplete = uint32(ioc(0, 'r', 6, 0))
+	brIncRefs             = uint32(ior('r', 7, binderPtrCookieSize))
+	brAcquire             = uint32(ior('r', 8, binderPtrCookieSize))
+	brRelease             = uint32(ior('r', 9, binderPtrCookieSize))
+	brDecrefs             = uint32(ior('r', 10, binderPtrCookieSize))
 	brNoop                = uint32(ioc(0, 'r', 12, 0))
 	brSpawnLooper         = uint32(ioc(0, 'r', 13, 0))
 	brFailedReply         = uint32(ioc(0, 'r', 17, 0))

parcel/binder_object.go

@@ -22,6 +22,30 @@ const (
 	flatBinderObjectSize = 24
 )
 
+// WriteLocalBinder writes a local binder object to the parcel.
+// The cookie identifies the object for incoming BR_TRANSACTION dispatch.
+// The kernel converts this to a handle in the remote process.
+func (p *Parcel) WriteLocalBinder(
+	cookie uintptr,
+) {
+	offset := uint64(p.Len())
+	p.objects = append(p.objects, offset)
+
+	buf := p.grow(flatBinderObjectSize)
+
+	// type (uint32, offset 0)
+	binary.LittleEndian.PutUint32(buf[0:], binderTypeBinder)
+
+	// flags (uint32, offset 4)
+	binary.LittleEndian.PutUint32(buf[4:], binderFlagsAcceptFDs)
+
+	// binder (binder_uintptr_t, offset 8)
+	binary.LittleEndian.PutUint64(buf[8:], uint64(cookie))
+
+	// cookie (binder_uintptr_t, offset 16)
+	binary.LittleEndian.PutUint64(buf[16:], uint64(cookie))
+}
+
 // WriteStrongBinder writes a flat_binder_object with the given handle.
 // Records the offset in the parcel's objects array.
 func (p *Parcel) WriteStrongBinder(