1/* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_TAG "BackupHelperDispatcher_native" 18#include <utils/Log.h> 19 20#include "JNIHelp.h" 21#include <android_runtime/AndroidRuntime.h> 22 23#include <sys/types.h> 24#include <sys/uio.h> 25#include <unistd.h> 26 27 28#define VERSION_1_HEADER 0x01706c48 // 'Hlp'1 little endian 29 30namespace android 31{ 32 33struct chunk_header_v1 { 34 int headerSize; 35 int version; 36 int dataSize; // corresponds to Header.chunkSize 37 int nameLength; // not including the NULL terminator, which is not written to the file 38}; 39 40// java.io.FileDescriptor 41static jfieldID s_descriptorField = 0; 42static jfieldID s_chunkSizeField = 0; 43static jfieldID s_keyPrefixField = 0; 44 45static int 46readHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) 47{ 48 chunk_header_v1 flattenedHeader; 49 int fd; 50 ssize_t amt; 51 String8 keyPrefix; 52 char* buf; 53 54 fd = env->GetIntField(fdObj, s_descriptorField); 55 56 amt = read(fd, &flattenedHeader.headerSize, sizeof(flattenedHeader.headerSize)); 57 if (amt != sizeof(flattenedHeader.headerSize)) { 58 return -1; 59 } 60 61 int remainingHeader = flattenedHeader.headerSize - sizeof(flattenedHeader.headerSize); 62 63 if (flattenedHeader.headerSize < (int)sizeof(chunk_header_v1)) { 64 LOGW("Skipping unknown header: %d bytes", flattenedHeader.headerSize); 65 if (remainingHeader > 0) { 66 lseek(fd, remainingHeader, SEEK_CUR); 67 // >0 means skip this chunk 68 return 1; 69 } 70 } 71 72 amt = read(fd, &flattenedHeader.version, 73 sizeof(chunk_header_v1)-sizeof(flattenedHeader.headerSize)); 74 if (amt <= 0) { 75 LOGW("Failed reading chunk header"); 76 return -1; 77 } 78 remainingHeader -= sizeof(chunk_header_v1)-sizeof(flattenedHeader.headerSize); 79 80 if (flattenedHeader.version != VERSION_1_HEADER) { 81 LOGW("Skipping unknown header version: 0x%08x, %d bytes", flattenedHeader.version, 82 flattenedHeader.headerSize); 83 if (remainingHeader > 0) { 84 lseek(fd, remainingHeader, SEEK_CUR); 85 // >0 means skip this chunk 86 return 1; 87 } 88 } 89 90#if 0 91 LOGD("chunk header:"); 92 LOGD(" headerSize=%d", flattenedHeader.headerSize); 93 LOGD(" version=0x%08x", flattenedHeader.version); 94 LOGD(" dataSize=%d", flattenedHeader.dataSize); 95 LOGD(" nameLength=%d", flattenedHeader.nameLength); 96#endif 97 98 if (flattenedHeader.dataSize < 0 || flattenedHeader.nameLength < 0 || 99 remainingHeader < flattenedHeader.nameLength) { 100 LOGW("Malformed V1 header remainingHeader=%d dataSize=%d nameLength=%d", remainingHeader, 101 flattenedHeader.dataSize, flattenedHeader.nameLength); 102 return -1; 103 } 104 105 buf = keyPrefix.lockBuffer(flattenedHeader.nameLength); 106 if (buf == NULL) { 107 LOGW("unable to allocate %d bytes", flattenedHeader.nameLength); 108 return -1; 109 } 110 111 amt = read(fd, buf, flattenedHeader.nameLength); 112 buf[flattenedHeader.nameLength] = 0; 113 114 keyPrefix.unlockBuffer(flattenedHeader.nameLength); 115 116 remainingHeader -= flattenedHeader.nameLength; 117 118 if (remainingHeader > 0) { 119 lseek(fd, remainingHeader, SEEK_CUR); 120 } 121 122 env->SetIntField(headerObj, s_chunkSizeField, flattenedHeader.dataSize); 123 env->SetObjectField(headerObj, s_keyPrefixField, env->NewStringUTF(keyPrefix.string())); 124 125 return 0; 126} 127 128static int 129skipChunk_native(JNIEnv* env, jobject clazz, jobject fdObj, jint bytesToSkip) 130{ 131 int fd; 132 133 fd = env->GetIntField(fdObj, s_descriptorField); 134 135 lseek(fd, bytesToSkip, SEEK_CUR); 136 137 return 0; 138} 139 140static int 141padding_len(int len) 142{ 143 len = len % 4; 144 return len == 0 ? len : 4 - len; 145} 146 147static int 148allocateHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj) 149{ 150 int pos; 151 jstring nameObj; 152 int nameLength; 153 int namePadding; 154 int headerSize; 155 int fd; 156 157 fd = env->GetIntField(fdObj, s_descriptorField); 158 159 nameObj = (jstring)env->GetObjectField(headerObj, s_keyPrefixField); 160 161 nameLength = env->GetStringUTFLength(nameObj); 162 namePadding = padding_len(nameLength); 163 164 headerSize = sizeof(chunk_header_v1) + nameLength + namePadding; 165 166 pos = lseek(fd, 0, SEEK_CUR); 167 168 lseek(fd, headerSize, SEEK_CUR); 169 170 return pos; 171} 172 173static int 174writeHeader_native(JNIEnv* env, jobject clazz, jobject headerObj, jobject fdObj, jint pos) 175{ 176 int err; 177 chunk_header_v1 header; 178 int fd; 179 int namePadding; 180 int prevPos; 181 jstring nameObj; 182 const char* buf; 183 184 fd = env->GetIntField(fdObj, s_descriptorField); 185 prevPos = lseek(fd, 0, SEEK_CUR); 186 187 nameObj = (jstring)env->GetObjectField(headerObj, s_keyPrefixField); 188 header.nameLength = env->GetStringUTFLength(nameObj); 189 namePadding = padding_len(header.nameLength); 190 191 header.headerSize = sizeof(chunk_header_v1) + header.nameLength + namePadding; 192 header.version = VERSION_1_HEADER; 193 header.dataSize = prevPos - (pos + header.headerSize); 194 195 lseek(fd, pos, SEEK_SET); 196 err = write(fd, &header, sizeof(chunk_header_v1)); 197 if (err != sizeof(chunk_header_v1)) { 198 return errno; 199 } 200 201 buf = env->GetStringUTFChars(nameObj, NULL); 202 err = write(fd, buf, header.nameLength); 203 env->ReleaseStringUTFChars(nameObj, buf); 204 if (err != header.nameLength) { 205 return errno; 206 } 207 208 if (namePadding != 0) { 209 int zero = 0; 210 err = write(fd, &zero, namePadding); 211 if (err != namePadding) { 212 return errno; 213 } 214 } 215 216 lseek(fd, prevPos, SEEK_SET); 217 return 0; 218} 219 220static const JNINativeMethod g_methods[] = { 221 { "readHeader_native", 222 "(Landroid/app/backup/BackupHelperDispatcher$Header;Ljava/io/FileDescriptor;)I", 223 (void*)readHeader_native }, 224 { "skipChunk_native", 225 "(Ljava/io/FileDescriptor;I)I", 226 (void*)skipChunk_native }, 227 { "allocateHeader_native", 228 "(Landroid/app/backup/BackupHelperDispatcher$Header;Ljava/io/FileDescriptor;)I", 229 (void*)allocateHeader_native }, 230 { "writeHeader_native", 231 "(Landroid/app/backup/BackupHelperDispatcher$Header;Ljava/io/FileDescriptor;I)I", 232 (void*)writeHeader_native }, 233}; 234 235int register_android_backup_BackupHelperDispatcher(JNIEnv* env) 236{ 237 jclass clazz; 238 239 clazz = env->FindClass("java/io/FileDescriptor"); 240 LOG_FATAL_IF(clazz == NULL, "Unable to find class java.io.FileDescriptor"); 241 s_descriptorField = env->GetFieldID(clazz, "descriptor", "I"); 242 LOG_FATAL_IF(s_descriptorField == NULL, 243 "Unable to find descriptor field in java.io.FileDescriptor"); 244 245 clazz = env->FindClass("android/app/backup/BackupHelperDispatcher$Header"); 246 LOG_FATAL_IF(clazz == NULL, 247 "Unable to find class android.app.backup.BackupHelperDispatcher.Header"); 248 s_chunkSizeField = env->GetFieldID(clazz, "chunkSize", "I"); 249 LOG_FATAL_IF(s_chunkSizeField == NULL, 250 "Unable to find chunkSize field in android.app.backup.BackupHelperDispatcher.Header"); 251 s_keyPrefixField = env->GetFieldID(clazz, "keyPrefix", "Ljava/lang/String;"); 252 LOG_FATAL_IF(s_keyPrefixField == NULL, 253 "Unable to find keyPrefix field in android.app.backup.BackupHelperDispatcher.Header"); 254 255 return AndroidRuntime::registerNativeMethods(env, "android/app/backup/BackupHelperDispatcher", 256 g_methods, NELEM(g_methods)); 257} 258 259} 260