int adb_status(int fd)
{
unsigned char buf[5];
unsigned len;
if(readx(fd, buf, 4)) {
strcpy(__adb_error, "protocol fault (no status)");
return -1;
}
if(!memcmp(buf, "OKAY", 4)) {
return 0;
}
if(memcmp(buf, "FAIL", 4)) {
sprintf(__adb_error,
"protocol fault (status %02x %02x %02x %02x?!)",
buf[0], buf[1], buf[2], buf[3]);
return -1;
}
if(readx(fd, buf, 4)) {
strcpy(__adb_error, "protocol fault (status len)");
return -1;
}
buf[4] = 0;
len = strtoul((char*)buf, 0, 16);
if(len > 255) len = 255;
if(readx(fd, __adb_error, len)) {
strcpy(__adb_error, "protocol fault (status read)");
return -1;
}
__adb_error[len] = 0;
return -1;
}
int main(const int argc, const char *argv[]) {
char buf[BUFFER_MAX];
struct sockaddr addr;
socklen_t alen;
int lsocket, s, count;
if (initialize_globals() < 0) {
LOGE("Could not initialize globals; exiting.\n");
exit(1);
}
if (initialize_directories() < 0) {
LOGE("Could not create directories; exiting.\n");
exit(1);
}
lsocket = android_get_control_socket(SOCKET_PATH);
if (lsocket < 0) {
LOGE("Failed to get socket from environment: %s\n", strerror(errno));
exit(1);
}
if (listen(lsocket, 5)) {
LOGE("Listen on socket failed: %s\n", strerror(errno));
exit(1);
}
fcntl(lsocket, F_SETFD, FD_CLOEXEC);
for (;;) {
alen = sizeof(addr);
s = accept(lsocket, &addr, &alen);
if (s < 0) {
LOGE("Accept failed: %s\n", strerror(errno));
continue;
}
fcntl(s, F_SETFD, FD_CLOEXEC);
LOGI("new connection\n");
for (;;) {
unsigned short count;
if (readx(s, &count, sizeof(count))) {
LOGE("failed to read size\n");
break;
}
if ((count < 1) || (count >= BUFFER_MAX)) {
LOGE("invalid size %d\n", count);
break;
}
if (readx(s, buf, count)) {
LOGE("failed to read command\n");
break;
}
buf[count] = 0;
if (execute(s, buf)) break;
}
LOGI("closing connection\n");
close(s);
}
return 0;
}
char *adb_query(const char *service) {
char buf[5];
unsigned n;
char *tmp;
D("adb_query: %s\n", service);
int fd = adb_connect(service);
if(fd < 0) {
fprintf(stderr,"error: %s\n", __adb_error);
return 0;
}
if(readx(fd, buf, 4)) goto oops;
buf[4] = 0;
n = strtoul(buf, 0, 16);
if(n >= 0xffff) {
strcpy(__adb_error, "reply is too long (>= 64kB)");
goto oops;
}
tmp = malloc(n + 1);
if(tmp == 0) goto oops;
if(readx(fd, tmp, n) == 0) {
tmp[n] = 0;
adb_close(fd);
return tmp;
}
free(tmp);
oops:
adb_close(fd);
return 0;
}
static int remote_read(apacket *p, atransport *t)
{
if(readx(t->sfd, &p->msg, sizeof(amessage))){
D("remote local: read terminated (message)\n");
return -1;
}
fix_endians(p);
#if 0 && defined __ppc__
D("read remote packet: %04x arg0=%0x arg1=%0x data_length=%0x data_check=%0x magic=%0x\n",
p->msg.command, p->msg.arg0, p->msg.arg1, p->msg.data_length, p->msg.data_check, p->msg.magic);
#endif
if(check_header(p)) {
D("bad header: terminated (data)\n");
return -1;
}
if(readx(t->sfd, p->data, p->msg.data_length)){
D("remote local: terminated (data)\n");
return -1;
}
if(check_data(p)) {
D("bad data: terminated (data)\n");
return -1;
}
return 0;
}
void framebuffer_service(int fd, void *cookie)
{
char x[512];
struct fbinfo fbinfo;
int w, h, f;
int s[2];
int fb;
unsigned int i;
int rv;
if(adb_socketpair(s)) {
printf("cannot create service socket pair\n");
goto done;
}
pid_t pid = fork();
if (pid < 0) {
printf("- fork failed: %s -\n", strerror(errno));
goto done;
}
if (pid == 0) {
dup2(s[1], STDOUT_FILENO);
const char* cmd_path = "/system/bin/screencap";
const char* cmd = "screencap";
execl(cmd_path, cmd, NULL);
exit(1);
}
fb = s[0];
/* read w, h, f */
if (readx(fb, &w, 4)) goto done;
if (readx(fb, &h, 4)) goto done;
if (readx(fb, &f, 4)) goto done;
fbinfo.version = DDMS_RAWIMAGE_VERSION;
fbinfo.size = w * h * 4;
fbinfo.width = w;
fbinfo.height = h;
rv = fill_format(&fbinfo, f);
if (rv != 0) goto done;
if(writex(fd, &fbinfo, sizeof(fbinfo))) goto done;
for(i = 0; i < fbinfo.size; i += sizeof(x)) {
if(readx(fb, &x, sizeof(x))) goto done;
if(writex(fd, &x, sizeof(x))) goto done;
}
if(readx(fb, &x, fbinfo.size % sizeof(x))) goto done;
if(writex(fd, &x, fbinfo.size % sizeof(x))) goto done;
done:
adb_close(s[0]);
adb_close(s[1]);
adb_close(fd);
}
void file_sync_service(int fd, void *cookie)
{
syncmsg msg;
char name[1025];
unsigned namelen;
char *buffer = malloc(SYNC_DATA_MAX);
if(buffer == 0) goto fail;
for(;;) {
D("sync: waiting for command\n");
if(readx(fd, &msg.req, sizeof(msg.req))) {
fail_message(fd, "command read failure");
break;
}
namelen = ltohl(msg.req.namelen);
if(namelen > 1024) {
fail_message(fd, "invalid namelen");
break;
}
if(readx(fd, name, namelen)) {
fail_message(fd, "filename read failure");
break;
}
name[namelen] = 0;
msg.req.namelen = 0;
D("sync: '%s' '%s'\n", (char*) &msg.req, name);
switch(msg.req.id) {
case ID_STAT:
if(do_stat(fd, name)) goto fail;
break;
case ID_LIST:
if(do_list(fd, name)) goto fail;
break;
case ID_SEND:
if(do_send(fd, name, buffer)) goto fail;
break;
case ID_RECV:
if(do_recv(fd, name, buffer)) goto fail;
break;
case ID_QUIT:
goto fail;
default:
fail_message(fd, "unknown command");
goto fail;
}
}
fail:
if(buffer != 0) free(buffer);
D("sync: done\n");
adb_close(fd);
}
void framebuffer_service(int fd, void *cookie)
{
struct fb_var_screeninfo vinfo;
int fb, offset;
char x[256];
struct fbinfo fbinfo;
unsigned i, bytespp;
fb = open("/dev/graphics/fb0", O_RDONLY);
if(fb < 0) goto done;
if(ioctl(fb, FBIOGET_VSCREENINFO, &vinfo) < 0) goto done;
fcntl(fb, F_SETFD, FD_CLOEXEC);
bytespp = vinfo.bits_per_pixel / 8;
fbinfo.version = DDMS_RAWIMAGE_VERSION;
fbinfo.bpp = vinfo.bits_per_pixel;
fbinfo.size = vinfo.xres * vinfo.yres * bytespp;
fbinfo.width = vinfo.xres;
fbinfo.height = vinfo.yres;
fbinfo.red_offset = vinfo.red.offset;
fbinfo.red_length = vinfo.red.length;
fbinfo.green_offset = vinfo.green.offset;
fbinfo.green_length = vinfo.green.length;
fbinfo.blue_offset = vinfo.blue.offset;
fbinfo.blue_length = vinfo.blue.length;
fbinfo.alpha_offset = vinfo.transp.offset;
fbinfo.alpha_length = vinfo.transp.length;
/* HACK: for several of our 3d cores a specific alignment
* is required so the start of the fb may not be an integer number of lines
* from the base. As a result we are storing the additional offset in
* xoffset. This is not the correct usage for xoffset, it should be added
* to each line, not just once at the beginning */
offset = vinfo.xoffset * bytespp;
offset += vinfo.xres * vinfo.yoffset * bytespp;
if(writex(fd, &fbinfo, sizeof(fbinfo))) goto done;
lseek(fb, offset, SEEK_SET);
for(i = 0; i < fbinfo.size; i += 256) {
if(readx(fb, &x, 256)) goto done;
if(writex(fd, &x, 256)) goto done;
}
if(readx(fb, &x, fbinfo.size % 256)) goto done;
if(writex(fd, &x, fbinfo.size % 256)) goto done;
done:
if(fb >= 0) close(fb);
close(fd);
}
static int handle_send_link(int s, char *path, char *buffer)
{
syncmsg msg;
unsigned int len;
int ret;
if(readx(s, &msg.data, sizeof(msg.data)))
return -1;
if(msg.data.id != ID_DATA) {
fail_message(s, "invalid data message: expected ID_DATA");
return -1;
}
len = ltohl(msg.data.size);
if(len > SYNC_DATA_MAX) {
fail_message(s, "oversize data message");
return -1;
}
if(readx(s, buffer, len))
return -1;
ret = symlink(buffer, path);
if(ret && errno == ENOENT) {
if(mkdirs(path) != 0) {
fail_errno(s);
return -1;
}
ret = symlink(buffer, path);
}
if(ret) {
fail_errno(s);
return -1;
}
if(readx(s, &msg.data, sizeof(msg.data)))
return -1;
if(msg.data.id == ID_DONE) {
msg.status.id = ID_OKAY;
msg.status.msglen = 0;
if(writex(s, &msg.status, sizeof(msg.status)))
return -1;
} else {
fail_message(s, "invalid data message: expected ID_DONE");
return -1;
}
return 0;
}
int main(const int argc, const char *argv[])
{
int server_fd, client_fd;
int read_size;
short cmd_len;
struct sockaddr addr;
socklen_t alen;
info_sys("backuprestore service start!");
if ((server_fd = srv_create_sk()) < 0)
err_sys("create socket server error");
alen = sizeof(addr);
info_sys("Server socket create successfully!");
while(1){
client_fd = accept(server_fd, (struct sockaddr*) &addr, &alen);
if (client_fd < 0) {
debug_sys("socket accept failed, please try again!");
continue;
}
info_sys("before excute");
while (1) {
cmd_len = 0;
if (readx(client_fd, &cmd_len, sizeof(cmd_len)) <= 0){
debug_sys("cmd length read fail");
break;
}
if (cmd_len < 1 || cmd_len > 2048){
debug_sys("cmd length is not right");
break;
}
if (readx(client_fd, &cmd, cmd_len) <= 0){
debug_sys("read cmd fail");
break;
}
cmd[cmd_len] = 0;
if (excute(client_fd, cmd) < 0)
break;
}
close(client_fd);
}
close(server_fd);
info_sys("backuprestore service end!");
return EXIT_SUCCESS;
}
static void recover_service(int s, void *cookie)
{
unsigned char buf[4096];
unsigned count = (unsigned) cookie;
int fd;
fd = adb_creat("/tmp/update", 0644);
if(fd < 0) {
adb_close(s);
return;
}
while(count > 0) {
unsigned xfer = (count > 4096) ? 4096 : count;
if(readx(s, buf, xfer)) break;
if(writex(fd, buf, xfer)) break;
count -= xfer;
}
if(count == 0) {
writex(s, "OKAY", 4);
} else {
writex(s, "FAIL", 4);
}
adb_close(fd);
adb_close(s);
fd = adb_creat("/tmp/update.begin", 0644);
adb_close(fd);
}
int sync_readtime(int fd, const char *path, unsigned int *timestamp,
unsigned int *mode)
{
syncmsg msg;
int len = strlen(path);
msg.req.id = ID_STAT;
msg.req.namelen = htoll(len);
if(writex(fd, &msg.req, sizeof(msg.req)) ||
writex(fd, path, len)) {
return -1;
}
if(readx(fd, &msg.stat, sizeof(msg.stat))) {
return -1;
}
if(msg.stat.id != ID_STAT) {
return -1;
}
*timestamp = ltohl(msg.stat.time);
*mode = ltohl(msg.stat.mode);
return 0;
}
void framebuffer_service(int fd, void *cookie)
{
struct fb_var_screeninfo vinfo;
int fb;
void *ptr = MAP_FAILED;
char x;
unsigned fbinfo[4];
fb = open("/dev/graphics/fb0", O_RDONLY);
if(fb < 0) goto done;
if(ioctl(fb, FBIOGET_VSCREENINFO, &vinfo) < 0) goto done;
fcntl(fb, F_SETFD, FD_CLOEXEC);
fbinfo[0] = 16;
fbinfo[1] = vinfo.xres * vinfo.yres * 2;
fbinfo[2] = vinfo.xres;
fbinfo[3] = vinfo.yres;
ptr = mmap(0, fbinfo[1], PROT_READ, MAP_SHARED, fb, 0);
if(ptr == MAP_FAILED) goto done;
if(writex(fd, fbinfo, sizeof(unsigned) * 4)) goto done;
for(;;) {
if(readx(fd, &x, 1)) goto done;
if(writex(fd, ptr, fbinfo[1])) goto done;
}
done:
if(ptr != MAP_FAILED) munmap(ptr, fbinfo[1]);
if(fb >= 0) close(fb);
close(fd);
}
int
getkval(unsigned long offset, caddr_t ptr, int size, char *refstr)
{
int upper_2gb = 0;
/* reads above 2Gb are done by seeking to offset%2Gb, and supplying
* 1 (opposed to 0) as fourth parameter to readx (see 'man kmem')
*/
if (offset > 1<<31) {
upper_2gb = 1;
offset &= 0x7fffffff;
}
if (lseek(kmem, offset, SEEK_SET) != offset) {
fprintf(stderr, "top: lseek failed\n");
quit(2);
}
if (readx(kmem, ptr, size, upper_2gb) != size) {
if (*refstr == '!')
return 0;
else {
fprintf(stderr, "top: kvm_read for %s: %s\n", refstr,
sys_errlist[errno]);
quit(2);
}
}
return 1 ;
}
static int upload(int s, int txfd, int txlen) {
char buf[65536];
msg_hdr_t hdr;
while (txlen > 0) {
int xfer = (txlen > 65536) ? 65536 : txlen;
if (readx(txfd, buf, xfer)) {
fprintf(stderr, "error: reading from file\n");
return -1;
}
hdr.opcode = MSG_SEND_DATA;
hdr.extra = 0;
hdr.length = xfer - 1;
if (write(s, &hdr, sizeof(hdr)) != sizeof(hdr)) {
fprintf(stderr, "error: writing socket\n");
return -1;
}
if (write(s, buf, xfer) != xfer) {
fprintf(stderr, "error: writing socket\n");
return -1;
}
txlen -= xfer;
}
hdr.opcode = MSG_END_DATA;
hdr.extra = 0;
hdr.length = 0;
if (write(s, &hdr, sizeof(hdr)) != sizeof(hdr)) {
fprintf(stderr, "error: writing socket\n");
return -1;
}
return 0;
}
int main(){
int i,j,k,l,k1,l1,test,t=1,q,ans;
//freopen("in.txt","r",stdin);
scanf("%d",&test);
while(test--){
memset(tree,0,sizeof(tree));
memset(fl,0,sizeof(fl));
scanf("%d",&q);
printf("Case %d:\n",t++);
for(i=1;i<=q;i++){
scanf("%d",&j);
if(j==0){
scanf("%d %d",&k,&l);
k++; l++;
if(fl[k][l]) continue;
fl[k][l]=1;
updatex(k,l,1);
}
else{
scanf("%d %d %d %d",&k,&l,&k1,&l1);
k++; l++; k1++; l1++;
ans=readx(k1,l1);
ans-=readx(k1,l);
ans-=readx(k,l1);
ans+=readx(k,l);
for(j=k;j<=k1;j++){
if(fl[j][l]) ans++;
}
for(j=l;j<=l1;j++){
if(fl[k][j]) ans++;
}
if(fl[k][l]) ans--;
//ans-=readx(k,l-1);
//ans+=readx(k-1,l-1);
printf("%d\n",ans);
}
}
}
return 0;
}
int adb_download_buffer(const char *service, const void* data, int sz,
unsigned progress)
{
char buf[4096];
unsigned total;
int fd;
const unsigned char *ptr;
sprintf(buf,"%s:%d", service, sz);
fd = adb_connect(buf);
if(fd < 0) {
fprintf(stderr,"error: %s\n", adb_error());
return -1;
}
int opt = CHUNK_SIZE;
opt = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const char *)&opt, sizeof(opt));
total = sz;
ptr = (const unsigned char *)data;
if(progress) {
char *x = strrchr((char*)service, ':');
if(x) service = x + 1;
}
while(sz > 0) {
unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz;
if(writex(fd, ptr, xfer)) {
adb_status(fd);
fprintf(stderr,"* failed to write data '%s' *\n", adb_error());
return -1;
}
sz -= xfer;
ptr += xfer;
if(progress) {
printf("sending: '%s' %4d%% \r", service, (int)(100LL - ((100LL * sz) / (total))));
fflush(stdout);
}
}
if(progress) {
printf("\n");
}
if(readx(fd, buf, 4)){
fprintf(stderr,"* error reading response *\n");
adb_close(fd);
return -1;
}
if(memcmp(buf, "OKAY", 4)) {
buf[4] = 0;
fprintf(stderr,"* error response '%s' *\n", buf);
adb_close(fd);
return -1;
}
adb_close(fd);
return 0;
}
static ptr read_list() {
INT t; ptr v, x;
t = read_token(&v);
if (t == r_RPAREN) return Snil;
x = readx(t, v);
return Scons(x, read_list());
}
static void fdevent_subproc_event_func(int fd, unsigned ev, void *userdata)
{
D("subproc handling on fd=%d ev=%04x\n", fd, ev);
// Hook oneself back into the fde's suitable for select() on read.
if ((fd < 0) || (fd >= fd_table_max)) {
FATAL("fd %d out of range for fd_table \n", fd);
}
fdevent *fde = fd_table[fd];
fdevent_add(fde, FDE_READ);
if (ev & FDE_READ) {
int subproc_fd;
if (readx(fd, &subproc_fd, sizeof(subproc_fd))) {
FATAL("Failed to read the subproc's fd from fd=%d\n", fd);
}
if ((subproc_fd < 0) || (subproc_fd >= fd_table_max)) {
D("subproc_fd %d out of range 0, fd_table_max=%d\n",
subproc_fd, fd_table_max);
return;
}
fdevent *subproc_fde = fd_table[subproc_fd];
if (!subproc_fde) {
D("subproc_fd %d cleared from fd_table\n", subproc_fd);
return;
}
if (subproc_fde->fd != subproc_fd) {
// Already reallocated?
D("subproc_fd %d != fd_table[].fd %d\n", subproc_fd,
subproc_fde->fd);
return;
}
subproc_fde->force_eof = 1;
int rcount = 0;
ioctl(subproc_fd, FIONREAD, &rcount);
D("subproc with fd=%d has rcount=%d err=%d\n",
subproc_fd, rcount, errno);
if (rcount) {
// If there is data left, it will show up in the select().
// This works because there is no other thread reading that
// data when in this fd_func().
return;
}
D("subproc_fde.state=%04x\n", subproc_fde->state);
subproc_fde->events |= FDE_READ;
if (subproc_fde->state & FDE_PENDING) {
return;
}
subproc_fde->state |= FDE_PENDING;
fdevent_call_fdfunc(subproc_fde);
}
}
static ptr read_top() {
INT t; ptr v;
t = read_token(&v);
switch (t) {
case r_EOF: return Seof_object;
case r_RPAREN: return read_top();
default: return readx(t, v);
}
}
bool AdbClient::adb_status()
{
char buf[5];
unsigned len;
adbSock.flush();
if(!readx(buf, 4)) {
__adb_error = "protocol fault (no status)";
return false;
}
if(!memcmp(buf, "OKAY", 4)) {
return true;
}
if(memcmp(buf, "FAIL", 4)) {
__adb_error.sprintf(
"protocol fault (status %02x %02x %02x %02x?!)",
buf[0], buf[1], buf[2], buf[3]);
return false;
}
if(!readx(buf, 4)) {
__adb_error = "protocol fault (status len)";
return false;
}
buf[4] = 0;
len = strtoul((char*)buf, 0, 16);
if(len > 255) len = 255;
char buf2[256];
if(!readx(buf2, len)) {
__adb_error = "protocol fault (status read)";
return false;
}
buf2[len] = 0;
__adb_error = buf2;
return false;
}
/*
* Read BTX file header.
*/
static void
getbtx(int fd, struct btx_hdr * btx)
{
if (readx(fd, btx, sizeof(*btx), 0) != sizeof(*btx) ||
btx->btx_magic[0] != BTX_MAG0 ||
btx->btx_magic[1] != BTX_MAG1 ||
btx->btx_magic[2] != BTX_MAG2)
errx(1, "%s: Not a BTX kernel", fname);
btx->btx_pgctl = le16toh(btx->btx_pgctl);
btx->btx_textsz = le16toh(btx->btx_textsz);
btx->btx_entry = le32toh(btx->btx_entry);
}
int sync_ls(int fd, const char *path, sync_ls_cb func, void *cookie)
{
syncmsg msg;
char buf[257];
int len;
len = strlen(path);
if(len > 1024) goto fail;
msg.req.id = ID_LIST;
msg.req.namelen = htoll(len);
if(writex(fd, &msg.req, sizeof(msg.req)) ||
writex(fd, path, len)) {
goto fail;
}
for(;;) {
if(readx(fd, &msg.dent, sizeof(msg.dent))) break;
if(msg.dent.id == ID_DONE) return 0;
if(msg.dent.id != ID_DENT) break;
len = ltohl(msg.dent.namelen);
if(len > 256) break;
if(readx(fd, buf, len)) break;
buf[len] = 0;
func(ltohl(msg.dent.mode),
ltohl(msg.dent.size),
ltohl(msg.dent.time),
buf, cookie);
}
fail:
adb_close(fd);
return -1;
}
/*
* Safe copy from input file to output file.
*/
static void
copy(int fdi, int fdo, size_t nbyte, off_t offset)
{
char buf[8192];
size_t n;
while (nbyte) {
if ((n = sizeof(buf)) > nbyte)
n = nbyte;
if (readx(fdi, buf, n, offset) != n)
errx(2, "%s: Short read", fname);
writex(fdo, buf, n);
nbyte -= n;
offset = -1;
}
}
static int sync_finish_readtime(int fd, unsigned int *timestamp,
unsigned int *mode, unsigned int *size)
{
syncmsg msg;
if(readx(fd, &msg.stat, sizeof(msg.stat)))
return -1;
if(msg.stat.id != ID_STAT)
return -1;
*timestamp = ltohl(msg.stat.time);
*mode = ltohl(msg.stat.mode);
*size = ltohl(msg.stat.size);
return 0;
}
static ptr readx(INT t, ptr v) {
switch (t) {
case r_EOF:
printf("unexpected EOF\n");
exit(1);
case r_LPAREN: return read_list();
case r_RPAREN:
printf("unexpected right paren ignored\n");
t = read_token(&v);
return readx(t, v);
case r_CONST: return v;
default:
printf("invalid token %d\n", t);
exit(1);
}
}
/*******************************************************************************
* Function Name : rt_I2C_read
* Description : 从I2C E2PROM 地址中读取一个字节 外部函数
* Input : address 地址
* Output : None
* Return : 读出数据
*******************************************************************************/
unsigned char rt_I2C_read(unsigned char address)
{
unsigned char i;
start();
writex(0xa0);
clock();
writex(address);
clock();
start();
writex(0xa1);
clock();
i=readx();
stop();
Delay();
return(i);
}
void framebuffer_service(int fd, void *cookie)
{
struct fbinfo fbinfo;
unsigned int i;
char buf[640];
int fd_screencap;
int w, h, f;
int fds[2];
if (pipe(fds) < 0) goto done;
pid_t pid = fork();
if (pid < 0) goto done;
if (pid == 0) {
dup2(fds[1], STDOUT_FILENO);
close(fds[0]);
close(fds[1]);
const char* command = "screencap";
const char *args[2] = {command, NULL};
execvp(command, (char**)args);
exit(1);
}
fd_screencap = fds[0];
/* read w, h & format */
if(readx(fd_screencap, &w, 4)) goto done;
if(readx(fd_screencap, &h, 4)) goto done;
if(readx(fd_screencap, &f, 4)) goto done;
fbinfo.version = DDMS_RAWIMAGE_VERSION;
/* see hardware/hardware.h */
switch (f) {
case 1: /* RGBA_8888 */
fbinfo.bpp = 32;
fbinfo.size = w * h * 4;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 0;
fbinfo.red_length = 8;
fbinfo.green_offset = 8;
fbinfo.green_length = 8;
fbinfo.blue_offset = 16;
fbinfo.blue_length = 8;
fbinfo.alpha_offset = 24;
fbinfo.alpha_length = 8;
break;
case 2: /* RGBX_8888 */
fbinfo.bpp = 32;
fbinfo.size = w * h * 4;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 0;
fbinfo.red_length = 8;
fbinfo.green_offset = 8;
fbinfo.green_length = 8;
fbinfo.blue_offset = 16;
fbinfo.blue_length = 8;
fbinfo.alpha_offset = 24;
fbinfo.alpha_length = 0;
break;
case 3: /* RGB_888 */
fbinfo.bpp = 24;
fbinfo.size = w * h * 3;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 0;
fbinfo.red_length = 8;
fbinfo.green_offset = 8;
fbinfo.green_length = 8;
fbinfo.blue_offset = 16;
fbinfo.blue_length = 8;
fbinfo.alpha_offset = 24;
fbinfo.alpha_length = 0;
break;
case 4: /* RGB_565 */
fbinfo.bpp = 16;
fbinfo.size = w * h * 2;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 11;
fbinfo.red_length = 5;
fbinfo.green_offset = 5;
fbinfo.green_length = 6;
fbinfo.blue_offset = 0;
fbinfo.blue_length = 5;
fbinfo.alpha_offset = 0;
fbinfo.alpha_length = 0;
break;
case 5: /* BGRA_8888 */
fbinfo.bpp = 32;
fbinfo.size = w * h * 4;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 16;
fbinfo.red_length = 8;
fbinfo.green_offset = 8;
fbinfo.green_length = 8;
fbinfo.blue_offset = 0;
fbinfo.blue_length = 8;
fbinfo.alpha_offset = 24;
fbinfo.alpha_length = 8;
break;
default:
goto done;
}
/* write header */
if(writex(fd, &fbinfo, sizeof(fbinfo))) goto done;
#if 0//this has bug, tellen modify 20120706
/* write data */
for(i = 0; i < fbinfo.size; i += sizeof(buf)) {
if(readx(fd_screencap, buf, sizeof(buf))) goto done;
if(writex(fd, buf, sizeof(buf))) goto done;
}
if(readx(fd_screencap, buf, fbinfo.size % sizeof(buf))) goto done;
if(writex(fd, buf, fbinfo.size % sizeof(buf))) goto done;
#else
{
int step = fbinfo.size/sizeof(buf);
for(i = 0; i < step; i ++) {
if(readx(fd_screencap, buf, sizeof(buf))) goto done;
if(writex(fd, buf, sizeof(buf))) goto done;
}
if((fbinfo.size % sizeof(buf)) > 0){
if(readx(fd_screencap, buf, fbinfo.size % sizeof(buf))) goto done;
if(writex(fd, buf, fbinfo.size % sizeof(buf))) goto done;
}
}
#endif
done:
close(fds[0]);
close(fds[1]);
close(fd);
}
int adb_connect(const char *service)
{
// first query the adb server's version
int fd = _adb_connect("host:version");
D("adb_connect: service %s\n", service);
if(fd == -2 && __adb_server_name) {
fprintf(stderr,"** Cannot start server on remote host\n");
return fd;
} else if(fd == -2) {
fprintf(stdout,"* daemon not running. starting it now on port %d *\n",
__adb_server_port);
start_server:
if(launch_server(__adb_server_port)) {
fprintf(stderr,"* failed to start daemon *\n");
return -1;
} else {
fprintf(stdout,"* daemon started successfully *\n");
}
/* give the server some time to start properly and detect devices */
adb_sleep_ms(3000);
// fall through to _adb_connect
} else {
// if server was running, check its version to make sure it is not out of date
char buf[100];
size_t n;
int version = ADB_SERVER_VERSION - 1;
// if we have a file descriptor, then parse version result
if(fd >= 0) {
if(readx(fd, buf, 4)) goto error;
buf[4] = 0;
n = strtoul(buf, 0, 16);
if(n > sizeof(buf)) goto error;
if(readx(fd, buf, n)) goto error;
adb_close(fd);
if (sscanf(buf, "%04x", &version) != 1) goto error;
} else {
// if fd is -1, then check for "unknown host service",
// which would indicate a version of adb that does not support the version command
if (strcmp(__adb_error, "unknown host service") != 0)
return fd;
}
if(version != ADB_SERVER_VERSION) {
printf("adb server is out of date. killing...\n");
fd = _adb_connect("host:kill");
adb_close(fd);
/* XXX can we better detect its death? */
adb_sleep_ms(2000);
goto start_server;
}
}
// if the command is start-server, we are done.
if (!strcmp(service, "host:start-server"))
return 0;
fd = _adb_connect(service);
if(fd == -1) {
D("_adb_connect error: %s", __adb_error);
} else if(fd == -2) {
fprintf(stderr,"** daemon still not running\n");
}
D("adb_connect: return fd %d\n", fd);
return fd;
error:
adb_close(fd);
return -1;
}
void framebuffer_service(int fd, void *cookie)
{
struct fbinfo fbinfo;
unsigned int i;
char buf[640];
int fd_screencap,fb;
int w, h, f;
int fds[2];
if (pipe(fds) < 0) goto done;
pid_t pid = fork();
if (pid < 0) goto done;
if (pid == 0) {
dup2(fds[1], STDOUT_FILENO);
close(fds[0]);
close(fds[1]);
#if (0 == LCDC_CAPTURE)
const char* command = "screencap";
const char *args[2] = {command, NULL};
execvp(command, (char**)args);
exit(1);
#else // #if (LCDC_CAPTURE)
if ((fb=open("/system/bin/lcdc_screen_cap",O_RDONLY)) >= 0){
close(fb);
const char * command = "lcdc_screen_cap";
const char *args[2] = {command, NULL};
execvp(command, (char**)args);
exit(1);
}
else{
lcdc_screen_cap();
exit(0);
}
#endif
}
fd_screencap = fds[0];
/* read w, h & format */
if(readx(fd_screencap, &w, 4)) goto error;
if(readx(fd_screencap, &h, 4)) goto error;
if(readx(fd_screencap, &f, 4)) goto error;
fbinfo.version = DDMS_RAWIMAGE_VERSION;
/* see hardware/hardware.h */
switch (f) {
case 1: /* RGBA_8888 */
fbinfo.bpp = 32;
fbinfo.size = w * h * 4;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 0;
fbinfo.red_length = 8;
fbinfo.green_offset = 8;
fbinfo.green_length = 8;
fbinfo.blue_offset = 16;
fbinfo.blue_length = 8;
fbinfo.alpha_offset = 24;
fbinfo.alpha_length = 8;
break;
case 2: /* RGBX_8888 */
fbinfo.bpp = 32;
fbinfo.size = w * h * 4;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 0;
fbinfo.red_length = 8;
fbinfo.green_offset = 8;
fbinfo.green_length = 8;
fbinfo.blue_offset = 16;
fbinfo.blue_length = 8;
fbinfo.alpha_offset = 24;
fbinfo.alpha_length = 0;
break;
case 3: /* RGB_888 */
fbinfo.bpp = 24;
fbinfo.size = w * h * 3;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 0;
fbinfo.red_length = 8;
fbinfo.green_offset = 8;
fbinfo.green_length = 8;
fbinfo.blue_offset = 16;
fbinfo.blue_length = 8;
fbinfo.alpha_offset = 24;
fbinfo.alpha_length = 0;
break;
case 4: /* RGB_565 */
fbinfo.bpp = 16;
fbinfo.size = w * h * 2;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 11;
fbinfo.red_length = 5;
fbinfo.green_offset = 5;
fbinfo.green_length = 6;
fbinfo.blue_offset = 0;
fbinfo.blue_length = 5;
fbinfo.alpha_offset = 0;
fbinfo.alpha_length = 0;
break;
case 5: /* BGRA_8888 */
fbinfo.bpp = 32;
fbinfo.size = w * h * 4;
fbinfo.width = w;
fbinfo.height = h;
fbinfo.red_offset = 16;
fbinfo.red_length = 8;
fbinfo.green_offset = 8;
fbinfo.green_length = 8;
fbinfo.blue_offset = 0;
fbinfo.blue_length = 8;
fbinfo.alpha_offset = 24;
fbinfo.alpha_length = 8;
break;
default:
goto done;
}
/* write header */
if(writex(fd, &fbinfo, sizeof(fbinfo))) goto error;
/* write data */
for(i = 0; i < fbinfo.size; i += sizeof(buf)) {
if ((fbinfo.size - i) < sizeof(buf)) {
break;
}
if(readx(fd_screencap, buf, sizeof(buf))) goto error;
if(writex(fd, buf, sizeof(buf))) goto error;
}
if(readx(fd_screencap, buf, fbinfo.size % sizeof(buf))) goto error;
if(writex(fd, buf, fbinfo.size % sizeof(buf))) goto error;
done:
TEMP_FAILURE_RETRY(waitpid(pid, NULL, 0));
goto close_fd;
error:
/*Alternatively, closes fds should also assure lcdc_screen_cap not block by wrting pipe*/
if(0 == kill(pid, SIGTERM)){
XLOGI("[ADB] Sent SIGTERM to process %d\n", pid);
}else{
XLOGE("[ADB] Failed to send SIGTERM to process %d, errno=%s\n",pid, strerror(errno));
/*Note that even parent process failed to send signal,
child process(lcdc_screen_cap) should still exit normally*/
}
goto close_fd;
close_fd:
close(fds[0]);
close(fds[1]);
close(fd);
}
int sync_recv(int fd, const char *rpath, const char *lpath, int show_progress)
{
syncmsg msg;
int len;
int lfd = -1;
char *buffer = send_buffer.data;
unsigned id;
unsigned long long size = 0;
len = strlen(rpath);
if(len > 1024) return -1;
if (show_progress) {
// Determine remote file size.
syncmsg stat_msg;
stat_msg.req.id = ID_STAT;
stat_msg.req.namelen = htoll(len);
if (writex(fd, &stat_msg.req, sizeof(stat_msg.req)) ||
writex(fd, rpath, len)) {
return -1;
}
if (readx(fd, &stat_msg.stat, sizeof(stat_msg.stat))) {
return -1;
}
if (stat_msg.stat.id != ID_STAT) return -1;
size = ltohl(stat_msg.stat.size);
}
msg.req.id = ID_RECV;
msg.req.namelen = htoll(len);
if(writex(fd, &msg.req, sizeof(msg.req)) ||
writex(fd, rpath, len)) {
return -1;
}
if(readx(fd, &msg.data, sizeof(msg.data))) {
return -1;
}
id = msg.data.id;
if((id == ID_DATA) || (id == ID_DONE)) {
adb_unlink(lpath);
mkdirs(lpath);
lfd = adb_creat(lpath, 0644);
if(lfd < 0) {
fprintf(stderr,"cannot create '%s': %s\n", lpath, strerror(errno));
return -1;
}
goto handle_data;
} else {
goto remote_error;
}
for(;;) {
if(readx(fd, &msg.data, sizeof(msg.data))) {
return -1;
}
id = msg.data.id;
handle_data:
len = ltohl(msg.data.size);
if(id == ID_DONE) break;
if(id != ID_DATA) goto remote_error;
if(len > SYNC_DATA_MAX) {
fprintf(stderr,"data overrun\n");
adb_close(lfd);
return -1;
}
if(readx(fd, buffer, len)) {
adb_close(lfd);
return -1;
}
if(writex(lfd, buffer, len)) {
fprintf(stderr,"cannot write '%s': %s\n", rpath, strerror(errno));
adb_close(lfd);
return -1;
}
total_bytes += len;
if (show_progress) {
print_transfer_progress(total_bytes, size);
}
}
adb_close(lfd);
return 0;
remote_error:
adb_close(lfd);
adb_unlink(lpath);
if(id == ID_FAIL) {
len = ltohl(msg.data.size);
if(len > 256) len = 256;
if(readx(fd, buffer, len)) {
return -1;
}
buffer[len] = 0;
} else {
memcpy(buffer, &id, 4);
buffer[4] = 0;
// strcpy(buffer,"unknown reason");
}
fprintf(stderr,"failed to copy '%s' to '%s': %s\n", rpath, lpath, buffer);
return 0;
}
