summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--meta-oe/recipes-devtools/android-tools/android-tools/0001-add-base64-implementation.patch351
-rw-r--r--meta-oe/recipes-devtools/android-tools/android-tools/0002-adb-Musl-fixes.patch134
-rw-r--r--meta-oe/recipes-devtools/android-tools/android-tools/adbd.mk1
-rw-r--r--meta-oe/recipes-devtools/android-tools/android-tools_5.1.1.r37.bb2
4 files changed, 488 insertions, 0 deletions
diff --git a/meta-oe/recipes-devtools/android-tools/android-tools/0001-add-base64-implementation.patch b/meta-oe/recipes-devtools/android-tools/android-tools/0001-add-base64-implementation.patch
new file mode 100644
index 0000000000..680d21f3ac
--- /dev/null
+++ b/meta-oe/recipes-devtools/android-tools/android-tools/0001-add-base64-implementation.patch
@@ -0,0 +1,351 @@
1From bbeb72f11c64f190b23abbed5f44311bd021bdc9 Mon Sep 17 00:00:00 2001
2From: Khem Raj <raj.khem@gmail.com>
3Date: Fri, 15 Sep 2017 15:46:38 -0700
4Subject: [PATCH 1/2] add base64 implementation
5
6musl needs it
7
8Signed-off-by: Khem Raj <raj.khem@gmail.com>
9---
10 system/core/adb/adb_auth_client.c | 2 +-
11 system/core/adb/base64.c | 315 ++++++++++++++++++++++++++++++++++++++
12 2 files changed, 316 insertions(+), 1 deletion(-)
13 create mode 100644 system/core/adb/base64.c
14
15diff --git a/system/core/adb/adb_auth_client.c b/system/core/adb/adb_auth_client.c
16index 55e9dca..104b413 100644
17--- a/system/core/adb/adb_auth_client.c
18+++ b/system/core/adb/adb_auth_client.c
19@@ -75,7 +75,7 @@ static void read_keys(const char *file, struct listnode *list)
20 if (sep)
21 *sep = '\0';
22
23- ret = __b64_pton(buf, (u_char *)&key->key, sizeof(key->key) + 4);
24+ ret = b64_pton(buf, (u_char *)&key->key, sizeof(key->key) + 4);
25 if (ret != sizeof(key->key)) {
26 D("%s: Invalid base64 data ret=%d\n", file, ret);
27 free(key);
28diff --git a/system/core/adb/base64.c b/system/core/adb/base64.c
29new file mode 100644
30index 0000000..95da284
31--- /dev/null
32+++ b/system/core/adb/base64.c
33@@ -0,0 +1,315 @@
34+/*
35+ * Copyright (c) 1996-1999 by Internet Software Consortium.
36+ *
37+ * Permission to use, copy, modify, and distribute this software for any
38+ * purpose with or without fee is hereby granted, provided that the above
39+ * copyright notice and this permission notice appear in all copies.
40+ *
41+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
42+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
43+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
44+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
45+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
46+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
47+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
48+ * SOFTWARE.
49+ */
50+
51+/*
52+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
53+ *
54+ * International Business Machines, Inc. (hereinafter called IBM) grants
55+ * permission under its copyrights to use, copy, modify, and distribute this
56+ * Software with or without fee, provided that the above copyright notice and
57+ * all paragraphs of this notice appear in all copies, and that the name of IBM
58+ * not be used in connection with the marketing of any product incorporating
59+ * the Software or modifications thereof, without specific, written prior
60+ * permission.
61+ *
62+ * To the extent it has a right to do so, IBM grants an immunity from suit
63+ * under its patents, if any, for the use, sale or manufacture of products to
64+ * the extent that such products are used for performing Domain Name System
65+ * dynamic updates in TCP/IP networks by means of the Software. No immunity is
66+ * granted for any product per se or for any other function of any product.
67+ *
68+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
69+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
70+ * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
71+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
72+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
73+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
74+ */
75+
76+#if !defined(LINT) && !defined(CODECENTER)
77+static const char rcsid[] = "$BINDId: base64.c,v 8.7 1999/10/13 16:39:33 vixie Exp $";
78+#endif /* not lint */
79+
80+#include <sys/types.h>
81+#include <sys/param.h>
82+#include <sys/socket.h>
83+
84+#include <netinet/in.h>
85+#include <arpa/inet.h>
86+#include <arpa/nameser.h>
87+
88+#include <ctype.h>
89+#include <resolv.h>
90+#include <stdio.h>
91+#include <stdlib.h>
92+#include <stdint.h>
93+#include <string.h>
94+
95+#define Assert(Cond) if (!(Cond)) abort()
96+
97+static const char Base64[] =
98+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
99+static const char Pad64 = '=';
100+
101+/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
102+ The following encoding technique is taken from RFC 1521 by Borenstein
103+ and Freed. It is reproduced here in a slightly edited form for
104+ convenience.
105+
106+ A 65-character subset of US-ASCII is used, enabling 6 bits to be
107+ represented per printable character. (The extra 65th character, "=",
108+ is used to signify a special processing function.)
109+
110+ The encoding process represents 24-bit groups of input bits as output
111+ strings of 4 encoded characters. Proceeding from left to right, a
112+ 24-bit input group is formed by concatenating 3 8-bit input groups.
113+ These 24 bits are then treated as 4 concatenated 6-bit groups, each
114+ of which is translated into a single digit in the base64 alphabet.
115+
116+ Each 6-bit group is used as an index into an array of 64 printable
117+ characters. The character referenced by the index is placed in the
118+ output string.
119+
120+ Table 1: The Base64 Alphabet
121+
122+ Value Encoding Value Encoding Value Encoding Value Encoding
123+ 0 A 17 R 34 i 51 z
124+ 1 B 18 S 35 j 52 0
125+ 2 C 19 T 36 k 53 1
126+ 3 D 20 U 37 l 54 2
127+ 4 E 21 V 38 m 55 3
128+ 5 F 22 W 39 n 56 4
129+ 6 G 23 X 40 o 57 5
130+ 7 H 24 Y 41 p 58 6
131+ 8 I 25 Z 42 q 59 7
132+ 9 J 26 a 43 r 60 8
133+ 10 K 27 b 44 s 61 9
134+ 11 L 28 c 45 t 62 +
135+ 12 M 29 d 46 u 63 /
136+ 13 N 30 e 47 v
137+ 14 O 31 f 48 w (pad) =
138+ 15 P 32 g 49 x
139+ 16 Q 33 h 50 y
140+
141+ Special processing is performed if fewer than 24 bits are available
142+ at the end of the data being encoded. A full encoding quantum is
143+ always completed at the end of a quantity. When fewer than 24 input
144+ bits are available in an input group, zero bits are added (on the
145+ right) to form an integral number of 6-bit groups. Padding at the
146+ end of the data is performed using the '=' character.
147+
148+ Since all base64 input is an integral number of octets, only the
149+ -------------------------------------------------
150+ following cases can arise:
151+
152+ (1) the final quantum of encoding input is an integral
153+ multiple of 24 bits; here, the final unit of encoded
154+ output will be an integral multiple of 4 characters
155+ with no "=" padding,
156+ (2) the final quantum of encoding input is exactly 8 bits;
157+ here, the final unit of encoded output will be two
158+ characters followed by two "=" padding characters, or
159+ (3) the final quantum of encoding input is exactly 16 bits;
160+ here, the final unit of encoded output will be three
161+ characters followed by one "=" padding character.
162+ */
163+
164+int
165+b64_ntop(const uint8_t* src, size_t srclength, char* target, size_t targsize)
166+{
167+ size_t datalength = 0;
168+ uint8_t input[3];
169+ uint8_t output[4];
170+ size_t i;
171+
172+ while (2 < srclength) {
173+ input[0] = *src++;
174+ input[1] = *src++;
175+ input[2] = *src++;
176+ srclength -= 3;
177+
178+ output[0] = input[0] >> 2;
179+ output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
180+ output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
181+ output[3] = input[2] & 0x3f;
182+ Assert(output[0] < 64);
183+ Assert(output[1] < 64);
184+ Assert(output[2] < 64);
185+ Assert(output[3] < 64);
186+
187+ if (datalength + 4 > targsize)
188+ return (-1);
189+ target[datalength++] = Base64[output[0]];
190+ target[datalength++] = Base64[output[1]];
191+ target[datalength++] = Base64[output[2]];
192+ target[datalength++] = Base64[output[3]];
193+ }
194+
195+ /* Now we worry about padding. */
196+ if (0 != srclength) {
197+ /* Get what's left. */
198+ input[0] = input[1] = input[2] = '\0';
199+ for (i = 0; i < srclength; i++)
200+ input[i] = *src++;
201+
202+ output[0] = input[0] >> 2;
203+ output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
204+ output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
205+ Assert(output[0] < 64);
206+ Assert(output[1] < 64);
207+ Assert(output[2] < 64);
208+
209+ if (datalength + 4 > targsize)
210+ return (-1);
211+ target[datalength++] = Base64[output[0]];
212+ target[datalength++] = Base64[output[1]];
213+ if (srclength == 1)
214+ target[datalength++] = Pad64;
215+ else
216+ target[datalength++] = Base64[output[2]];
217+ target[datalength++] = Pad64;
218+ }
219+ if (datalength >= targsize)
220+ return (-1);
221+ target[datalength] = '\0'; /* Returned value doesn't count \0. */
222+ return (datalength);
223+}
224+
225+/* skips all whitespace anywhere.
226+ converts characters, four at a time, starting at (or after)
227+ src from base - 64 numbers into three 8 bit bytes in the target area.
228+ it returns the number of data bytes stored at the target, or -1 on error.
229+ */
230+
231+int b64_pton(const char* src, uint8_t* target, size_t targsize)
232+{
233+ int tarindex, state, ch;
234+ char *pos;
235+
236+ state = 0;
237+ tarindex = 0;
238+
239+ while ((ch = *src++) != '\0') {
240+ if (isspace(ch)) /* Skip whitespace anywhere. */
241+ continue;
242+
243+ if (ch == Pad64)
244+ break;
245+
246+ pos = strchr(Base64, ch);
247+ if (pos == 0) /* A non-base64 character. */
248+ return (-1);
249+
250+ switch (state) {
251+ case 0:
252+ if (target) {
253+ if ((size_t)tarindex >= targsize)
254+ return (-1);
255+ target[tarindex] = (pos - Base64) << 2;
256+ }
257+ state = 1;
258+ break;
259+ case 1:
260+ if (target) {
261+ if ((size_t)tarindex + 1 >= targsize)
262+ return (-1);
263+ target[tarindex] |= (pos - Base64) >> 4;
264+ target[tarindex+1] = ((pos - Base64) & 0x0f)
265+ << 4 ;
266+ }
267+ tarindex++;
268+ state = 2;
269+ break;
270+ case 2:
271+ if (target) {
272+ if ((size_t)tarindex + 1 >= targsize)
273+ return (-1);
274+ target[tarindex] |= (pos - Base64) >> 2;
275+ target[tarindex+1] = ((pos - Base64) & 0x03)
276+ << 6;
277+ }
278+ tarindex++;
279+ state = 3;
280+ break;
281+ case 3:
282+ if (target) {
283+ if ((size_t)tarindex >= targsize)
284+ return (-1);
285+ target[tarindex] |= (pos - Base64);
286+ }
287+ tarindex++;
288+ state = 0;
289+ break;
290+ default:
291+ abort();
292+ }
293+ }
294+
295+ /*
296+ * We are done decoding Base-64 chars. Let's see if we ended
297+ * on a byte boundary, and/or with erroneous trailing characters.
298+ */
299+
300+ if (ch == Pad64) { /* We got a pad char. */
301+ ch = *src++; /* Skip it, get next. */
302+ switch (state) {
303+ case 0: /* Invalid = in first position */
304+ case 1: /* Invalid = in second position */
305+ return (-1);
306+
307+ case 2: /* Valid, means one byte of info */
308+ /* Skip any number of spaces. */
309+ for ((void)NULL; ch != '\0'; ch = *src++)
310+ if (!isspace(ch))
311+ break;
312+ /* Make sure there is another trailing = sign. */
313+ if (ch != Pad64)
314+ return (-1);
315+ ch = *src++; /* Skip the = */
316+ /* Fall through to "single trailing =" case. */
317+ /* FALLTHROUGH */
318+
319+ case 3: /* Valid, means two bytes of info */
320+ /*
321+ * We know this char is an =. Is there anything but
322+ * whitespace after it?
323+ */
324+ for ((void)NULL; ch != '\0'; ch = *src++)
325+ if (!isspace(ch))
326+ return (-1);
327+
328+ /*
329+ * Now make sure for cases 2 and 3 that the "extra"
330+ * bits that slopped past the last full byte were
331+ * zeros. If we don't check them, they become a
332+ * subliminal channel.
333+ */
334+ if (target && target[tarindex] != 0)
335+ return (-1);
336+ }
337+ } else {
338+ /*
339+ * We ended by seeing the end of the string. Make sure we
340+ * have no partial bytes lying around.
341+ */
342+ if (state != 0)
343+ return (-1);
344+ }
345+
346+ return (tarindex);
347+}
348+
349--
3502.14.1
351
diff --git a/meta-oe/recipes-devtools/android-tools/android-tools/0002-adb-Musl-fixes.patch b/meta-oe/recipes-devtools/android-tools/android-tools/0002-adb-Musl-fixes.patch
new file mode 100644
index 0000000000..c7aebb6411
--- /dev/null
+++ b/meta-oe/recipes-devtools/android-tools/android-tools/0002-adb-Musl-fixes.patch
@@ -0,0 +1,134 @@
1From f8653ed0ede4aa781ab758fcd44fdc05ffbe0b0a Mon Sep 17 00:00:00 2001
2From: Khem Raj <raj.khem@gmail.com>
3Date: Fri, 15 Sep 2017 15:50:57 -0700
4Subject: [PATCH 2/2] adb: Musl fixes
5
6__nonnull is gcc specific
7include sys/types.h for size_t
8Do not redefine close() and lseek()
9
10Signed-off-by: Khem Raj <raj.khem@gmail.com>
11---
12 system/core/adb/adb.h | 2 ++
13 system/core/adb/disable_verity_service.c | 13 ++++++++-----
14 system/core/adb/framebuffer_service.c | 7 ++++---
15 system/core/adb/sysdeps.h | 12 ++++++------
16 4 files changed, 20 insertions(+), 14 deletions(-)
17
18diff --git a/system/core/adb/adb.h b/system/core/adb/adb.h
19index 44e5981..bcdc49f 100644
20--- a/system/core/adb/adb.h
21+++ b/system/core/adb/adb.h
22@@ -18,7 +18,9 @@
23 #define __ADB_H
24
25 #include <limits.h>
26+#include <sys/types.h>
27
28+#include "fdevent.h"
29 #include "adb_trace.h"
30 #include "transport.h" /* readx(), writex() */
31
32diff --git a/system/core/adb/disable_verity_service.c b/system/core/adb/disable_verity_service.c
33index ed3da52..29fa3d6 100644
34--- a/system/core/adb/disable_verity_service.c
35+++ b/system/core/adb/disable_verity_service.c
36@@ -14,25 +14,28 @@
37 * limitations under the License.
38 */
39
40-#include "sysdeps.h"
41
42 #define TRACE_TAG TRACE_ADB
43 #include "adb.h"
44+#include "sysdeps.h"
45+#include "cutils/properties.h"
46+#include "ext4_sb.h"
47+#include <fs_mgr.h>
48
49 #include <stdio.h>
50 #include <stdarg.h>
51 #include <sys/stat.h>
52 #include <fcntl.h>
53 #include <inttypes.h>
54+#include <unistd.h>
55+#include <errno.h>
56+#include <stdbool.h>
57
58-#include "cutils/properties.h"
59-#include "ext4_sb.h"
60-#include <fs_mgr.h>
61
62 #define FSTAB_PREFIX "/fstab."
63 struct fstab *fstab;
64
65-__attribute__((__format__(printf, 2, 3))) __nonnull((2))
66+__attribute__((__format__(printf, 2, 3))) __attribute__((nonnull((2))))
67 static void write_console(int fd, const char* format, ...)
68 {
69 char buffer[256];
70diff --git a/system/core/adb/framebuffer_service.c b/system/core/adb/framebuffer_service.c
71index 8cbe840..8f0ccfb 100644
72--- a/system/core/adb/framebuffer_service.c
73+++ b/system/core/adb/framebuffer_service.c
74@@ -14,6 +14,10 @@
75 * limitations under the License.
76 */
77
78+#include "fdevent.h"
79+#include "adb.h"
80+#include "sysdeps.h"
81+
82 #include <stdlib.h>
83 #include <stdio.h>
84 #include <unistd.h>
85@@ -23,9 +27,6 @@
86 #include <sys/types.h>
87 #include <sys/wait.h>
88
89-#include "fdevent.h"
90-#include "adb.h"
91-
92 #include <linux/fb.h>
93 #include <sys/ioctl.h>
94 #include <sys/mman.h>
95diff --git a/system/core/adb/sysdeps.h b/system/core/adb/sysdeps.h
96index cc1f839..ea39ac3 100644
97--- a/system/core/adb/sysdeps.h
98+++ b/system/core/adb/sysdeps.h
99@@ -123,8 +123,8 @@ static __inline__ int unix_close(int fd)
100 {
101 return close(fd);
102 }
103-#undef close
104-#define close ____xxx_close
105+//#undef close
106+//#define close ____xxx_close
107
108 static __inline__ int unix_read(int fd, void* buf, size_t len)
109 {
110@@ -369,8 +369,8 @@ static __inline__ int adb_close(int fd)
111 {
112 return close(fd);
113 }
114-#undef close
115-#define close ____xxx_close
116+//#undef close
117+//#define close ____xxx_close
118
119
120 static __inline__ int adb_read(int fd, void* buf, size_t len)
121@@ -392,8 +392,8 @@ static __inline__ int adb_lseek(int fd, int pos, int where)
122 {
123 return lseek(fd, pos, where);
124 }
125-#undef lseek
126-#define lseek ___xxx_lseek
127+//#undef lseek
128+//#define lseek ___xxx_lseek
129
130 static __inline__ int adb_unlink(const char* path)
131 {
132--
1332.14.1
134
diff --git a/meta-oe/recipes-devtools/android-tools/android-tools/adbd.mk b/meta-oe/recipes-devtools/android-tools/android-tools/adbd.mk
index 84cd06b109..31452ae104 100644
--- a/meta-oe/recipes-devtools/android-tools/android-tools/adbd.mk
+++ b/meta-oe/recipes-devtools/android-tools/android-tools/adbd.mk
@@ -16,6 +16,7 @@ adbd_SRC_FILES += jdwp_service.c
16adbd_SRC_FILES += framebuffer_service.c 16adbd_SRC_FILES += framebuffer_service.c
17adbd_SRC_FILES += remount_service.c 17adbd_SRC_FILES += remount_service.c
18adbd_SRC_FILES += disable_verity_service.c 18adbd_SRC_FILES += disable_verity_service.c
19adbd_SRC_FILES += base64.c
19adbd_SRC_FILES += usb_linux_client.c 20adbd_SRC_FILES += usb_linux_client.c
20adbd_OBJS := $(adbd_SRC_FILES:.c=.o) 21adbd_OBJS := $(adbd_SRC_FILES:.c=.o)
21 22
diff --git a/meta-oe/recipes-devtools/android-tools/android-tools_5.1.1.r37.bb b/meta-oe/recipes-devtools/android-tools/android-tools_5.1.1.r37.bb
index 34fddcbda7..75f5b9e26d 100644
--- a/meta-oe/recipes-devtools/android-tools/android-tools_5.1.1.r37.bb
+++ b/meta-oe/recipes-devtools/android-tools/android-tools_5.1.1.r37.bb
@@ -32,6 +32,8 @@ SRC_URI = " \
32 file://define-shell-command.patch \ 32 file://define-shell-command.patch \
33 file://implicit-declaration-function-strlcat-strlcopy.patch \ 33 file://implicit-declaration-function-strlcat-strlcopy.patch \
34 file://fix-big-endian-build.patch \ 34 file://fix-big-endian-build.patch \
35 file://0001-add-base64-implementation.patch \
36 file://0002-adb-Musl-fixes.patch \
35 file://android-tools-adbd.service \ 37 file://android-tools-adbd.service \
36 file://.gitignore;subdir=git \ 38 file://.gitignore;subdir=git \
37 file://adb.mk;subdir=${BPN} \ 39 file://adb.mk;subdir=${BPN} \
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2025-10-29 12:38:36 +0000