/* void RegisterSession(struct S_Encapsulation_Data *pa_S_ReceiveData) * Check supported protocol, generate session handle, send replay back to originator. * pa_nSockfd socket this request is associated to. Needed for double register check * pa_S_ReceiveData pointer to received data with request/response. */ void handleReceivedRegisterSessionCmd(int pa_nSockfd, struct S_Encapsulation_Data * pa_stReceiveData) { int i; int nSessionIndex = 0; EIP_UINT8 *pacBuf; EIP_UINT16 nProtocolVersion = ltohs( &pa_stReceiveData->m_acCurrentCommBufferPos); EIP_UINT16 nOptionFlag = ltohs(&pa_stReceiveData->m_acCurrentCommBufferPos); /* check if requested protocol version is supported and the register session option flag is zero*/ if ((0 < nProtocolVersion) && (nProtocolVersion <= SUPPORTED_PROTOCOL_VERSION) && (0 == nOptionFlag)) { /*Option field should be zero*/ /* check if the socket has already a session open */ for (i = 0; i < OPENER_NUMBER_OF_SUPPORTED_SESSIONS; ++i) { if (anRegisteredSessions[i] == pa_nSockfd) { /* the socket has already registered a session this is not allowed*/ pa_stReceiveData->nSession_handle = i + 1; /*return the already assigned session back, the cip spec is not clear about this needs to be tested*/ pa_stReceiveData->nStatus = OPENER_ENCAP_STATUS_UNSUPPORTED_PROTOCOL; nSessionIndex = INVALID_SESSION; pacBuf = &pa_stReceiveData->m_acCommBufferStart[ENCAPSULATION_HEADER_SESSION_HANDLE_POS]; htoll(pa_stReceiveData->nSession_handle, &pacBuf); /*encapsulate_data will not update the session handle so we have to do it here by hand*/ break; } } if (INVALID_SESSION != nSessionIndex) { nSessionIndex = getFreeSessionIndex(); if (INVALID_SESSION == nSessionIndex) /* no more sessions available */ { pa_stReceiveData->nStatus = OPENER_ENCAP_STATUS_INSUFFICIENT_MEM; } else { /* successful session registered */ anRegisteredSessions[nSessionIndex] = pa_nSockfd; /* store associated socket */ pa_stReceiveData->nSession_handle = nSessionIndex + 1; pa_stReceiveData->nStatus = OPENER_ENCAP_STATUS_SUCCESS; pacBuf = &pa_stReceiveData->m_acCommBufferStart[ENCAPSULATION_HEADER_SESSION_HANDLE_POS]; htoll(pa_stReceiveData->nSession_handle, &pacBuf); /*encapsulate_data will not update the session handle so we have to do it here by hand*/ } } } else { /* protocol not supported */ pa_stReceiveData->nStatus = OPENER_ENCAP_STATUS_UNSUPPORTED_PROTOCOL; } pa_stReceiveData->nData_length = 4; }
static int do_list(int s, const char *path) { DIR *d; struct dirent *de; struct stat st; syncmsg msg; int len; char tmp[1024 + 256 + 1]; char *fname; len = strlen(path); memcpy(tmp, path, len); tmp[len] = '/'; fname = tmp + len + 1; msg.dent.id = ID_DENT; d = opendir(path); if(d == 0) goto done; while((de = readdir(d))) { int len = strlen(de->d_name); /* not supposed to be possible, but if it does happen, let's not buffer overrun */ if(len > 256) continue; strcpy(fname, de->d_name); if(lstat(tmp, &st) == 0) { msg.dent.mode = htoll(st.st_mode); msg.dent.size = htoll(st.st_size); msg.dent.time = htoll(st.st_mtime); msg.dent.namelen = htoll(len); if(writex(s, &msg.dent, sizeof(msg.dent)) || writex(s, de->d_name, len)) { closedir(d); return -1; } } } closedir(d); done: msg.dent.id = ID_DONE; msg.dent.mode = 0; msg.dent.size = 0; msg.dent.time = 0; msg.dent.namelen = 0; return writex(s, &msg.dent, sizeof(msg.dent)); }
U64 getHex(void) { char c, str[20]; int i = 0; U64 val; printf(": "); while ((c = GET_KEY()) != NEWLINE) { if (c == BACKSPACE) { if (i) i--; else putchar(' '); printf(" \b"); } else if (ishex(c)) str[i++] = c; else Gripe(); if (i > 16) { putchar(7); break; } } str[i] = 0; val = htoll(str); return (val); }
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; }
static int write_data_buffer(int fd, char* file_buffer, int size, syncsendbuf *sbuf, int show_progress) { int err = 0; int total = 0; sbuf->id = ID_DATA; while (total < size) { int count = size - total; if (count > SYNC_DATA_MAX) { count = SYNC_DATA_MAX; } memcpy(sbuf->data, &file_buffer[total], count); sbuf->size = htoll(count); if(writex(fd, sbuf, sizeof(unsigned) * 2 + count)){ err = -1; break; } total += count; total_bytes += count; if (show_progress) { print_transfer_progress(total, size); } } return err; }
static int update_header(FILE *f) { off_t cur, end; uint32_t datalen; int bytes; cur = ftell(f); fseek(f, 0, SEEK_END); end = ftell(f); /* data starts 24 bytes in */ bytes = end - AU_HEADER_SIZE; datalen = htoll(bytes); if (cur < 0) { ast_log(LOG_WARNING, "Unable to find our position\n"); return -1; } if (fseek(f, AU_HDR_DATA_SIZE_OFF * sizeof(uint32_t), SEEK_SET)) { ast_log(LOG_WARNING, "Unable to set our position\n"); return -1; } if (fwrite(&datalen, 1, sizeof(datalen), f) != sizeof(datalen)) { ast_log(LOG_WARNING, "Unable to set write file size\n"); return -1; } if (fseek(f, cur, SEEK_SET)) { ast_log(LOG_WARNING, "Unable to return to position\n"); return -1; } return 0; }
static int sync_ls(int fd, const char* path, sync_ls_cb func, void* cookie) { int len = strlen(path); if (len > 1024) goto fail; syncmsg msg; msg.req.id = ID_LIST; msg.req.namelen = htoll(len); if (!WriteFdExactly(fd, &msg.req, sizeof(msg.req)) || !WriteFdExactly(fd, path, len)) { goto fail; } for (;;) { if (!ReadFdExactly(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; char buf[257]; if (!ReadFdExactly(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; }
static int update_header(FILE *f) { off_t cur,end,bytes; int datalen, filelen, samples; cur = ftello(f); fseek(f, 0, SEEK_END); end = ftello(f); /* in a gsm WAV, data starts 60 bytes in */ bytes = end - MSGSM_DATA_OFFSET; samples = htoll(bytes / MSGSM_FRAME_SIZE * MSGSM_SAMPLES); datalen = htoll(bytes); filelen = htoll(MSGSM_DATA_OFFSET - 8 + bytes); if (cur < 0) { ast_log(LOG_WARNING, "Unable to find our position\n"); return -1; } if (fseek(f, 4, SEEK_SET)) { ast_log(LOG_WARNING, "Unable to set our position\n"); return -1; } if (fwrite(&filelen, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write file size\n"); return -1; } if (fseek(f, 48, SEEK_SET)) { ast_log(LOG_WARNING, "Unable to set our position\n"); return -1; } if (fwrite(&samples, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write samples\n"); return -1; } if (fseek(f, 56, SEEK_SET)) { ast_log(LOG_WARNING, "Unable to set our position\n"); return -1; } if (fwrite(&datalen, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write datalen\n"); return -1; } if (fseeko(f, cur, SEEK_SET)) { ast_log(LOG_WARNING, "Unable to return to position\n"); return -1; } return 0; }
static int write_header(FILE *f) { AU_HEADER(header); header[AU_HDR_MAGIC_OFF] = htoll((uint32_t) AU_MAGIC); header[AU_HDR_HDR_SIZE_OFF] = htoll(AU_HEADER_SIZE); header[AU_HDR_DATA_SIZE_OFF] = 0; header[AU_HDR_ENCODING_OFF] = htoll(AU_ENC_8BIT_ULAW); header[AU_HDR_SAMPLE_RATE_OFF] = htoll(DEFAULT_SAMPLE_RATE); header[AU_HDR_CHANNELS_OFF] = htoll(1); /* Write an au header, ignoring sizes which will be filled in later */ fseek(f, 0, SEEK_SET); if (fwrite(header, 1, AU_HEADER_SIZE, f) != AU_HEADER_SIZE) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } return 0; }
static int do_stat(int s, const char *path) { syncmsg msg; struct stat st; msg.stat.id = ID_STAT; if(lstat(path, &st)) { msg.stat.mode = 0; msg.stat.size = 0; msg.stat.time = 0; } else { msg.stat.mode = htoll(st.st_mode); msg.stat.size = htoll(st.st_size); msg.stat.time = htoll(st.st_mtime); } return writex(s, &msg.stat, sizeof(msg.stat)); }
int wav_update_header(FILE *f) { off_t cur,end; int datalen,filelen,bytes; cur = ftello(f); fseek(f, 0, SEEK_END); end = ftello(f); /* data starts 44 bytes in */ bytes = end - 44; datalen = htoll(bytes); /* chunk size is bytes of data plus 36 bytes of header */ filelen = htoll(36 + bytes); if (cur < 0) { //log(LOG_WARNING, "Unable to find our position\n"); return -1; } if (fseek(f, 4, SEEK_SET)) { //log(LOG_WARNING, "Unable to set our position\n"); return -1; } if (fwrite(&filelen, 1, 4, f) != 4) { //log(LOG_WARNING, "Unable to set write file size\n"); return -1; } if (fseek(f, 40, SEEK_SET)) { //log(LOG_WARNING, "Unable to set our position\n"); return -1; } if (fwrite(&datalen, 1, 4, f) != 4) { //log(LOG_WARNING, "Unable to set write datalen\n"); return -1; } if (fseeko(f, cur, SEEK_SET)) { //log(LOG_WARNING, "Unable to return to position\n"); return -1; } return 0; }
static int write_data_file(int fd, const char *path, syncsendbuf *sbuf, int show_progress) { int lfd, err = 0; unsigned long long size = 0; lfd = adb_open(path, O_RDONLY); if(lfd < 0) { fprintf(stderr,"cannot open '%s': %s\n", path, strerror(errno)); return -1; } if (show_progress) { // Determine local file size. struct stat st; if (fstat(lfd, &st)) { fprintf(stderr,"cannot stat '%s': %s\n", path, strerror(errno)); return -1; } size = st.st_size; } sbuf->id = ID_DATA; for(;;) { int ret; ret = adb_read(lfd, sbuf->data, SYNC_DATA_MAX); if(!ret) break; if(ret < 0) { if(errno == EINTR) continue; fprintf(stderr,"cannot read '%s': %s\n", path, strerror(errno)); break; } sbuf->size = htoll(ret); if(writex(fd, sbuf, sizeof(unsigned) * 2 + ret)){ err = -1; break; } total_bytes += ret; if (show_progress) { print_transfer_progress(total_bytes, size); } } adb_close(lfd); return err; }
static int update_header(int fd) { off_t cur,end,bytes; int datalen,filelen; cur = lseek(fd, 0, SEEK_CUR); end = lseek(fd, 0, SEEK_END); /* in a gsm WAV, data starts 60 bytes in */ bytes = end - 60; datalen = htoll((bytes + 1) & ~0x1); filelen = htoll(52 + ((bytes + 1) & ~0x1)); if (cur < 0) { ast_log(LOG_WARNING, "Unable to find our position\n"); return -1; } if (lseek(fd, 4, SEEK_SET) != 4) { ast_log(LOG_WARNING, "Unable to set our position\n"); return -1; } if (write(fd, &filelen, 4) != 4) { ast_log(LOG_WARNING, "Unable to set write file size\n"); return -1; } if (lseek(fd, 56, SEEK_SET) != 56) { ast_log(LOG_WARNING, "Unable to set our position\n"); return -1; } if (write(fd, &datalen, 4) != 4) { ast_log(LOG_WARNING, "Unable to set write datalen\n"); return -1; } if (lseek(fd, cur, SEEK_SET) != cur) { ast_log(LOG_WARNING, "Unable to return to position\n"); return -1; } return 0; }
static int sync_start_readtime(int fd, const char *path) { 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; } return 0; }
static int fail_message(int s, const char *reason) { syncmsg msg; int len = strlen(reason); D("sync: failure: %s\n", reason); msg.data.id = ID_FAIL; msg.data.size = htoll(len); if(writex(s, &msg.data, sizeof(msg.data)) || writex(s, reason, len)) { return -1; } else { return 0; } }
int encapsulate_data(struct S_Encapsulation_Data *pa_stSendData) { EIP_UINT8 *acCommBuf = &(pa_stSendData->m_acCommBufferStart[2]); /*htols(pa_stSendData->nCommand_code, &pa_stSendData->pEncapsulation_Data);*/ htols(pa_stSendData->nData_length, &acCommBuf); /*the CommBuf should already contain the correct session handle*/ /*htoll(pa_stSendData->nSession_handle, &pa_stSendData->pEncapsulation_Data); */ acCommBuf += 4; htoll(pa_stSendData->nStatus, &acCommBuf); /*the CommBuf should already contain the correct sender context*/ /*memcpy(pa_stSendData->pEncapsulation_Data, pa_stSendData->anSender_context, SENDER_CONTEXT_SIZE);*/ /*pa_stSendData->pEncapsulation_Data += SENDER_CONTEXT_SIZE + 2;*//* the plus 2 is for the options value*/ /*the CommBuf should already contain the correct options value*/ /*htols((EIP_UINT16)pa_stSendData->nOptions, &pa_stSendData->pEncapsulation_Data);*/ return ENCAPSULATION_HEADER_LENGTH + pa_stSendData->nData_length; }
static int write_data_link(int fd, const char *path, syncsendbuf *sbuf) { int len = readlink(path, sbuf->data, SYNC_DATA_MAX-1); if (len < 0) { fprintf(stderr, "error reading link '%s': %s\n", path, strerror(errno)); return -1; } sbuf->data[len] = '\0'; sbuf->size = htoll(len + 1); sbuf->id = ID_DATA; if (!WriteFdExactly(fd, sbuf, sizeof(unsigned) * 2 + len + 1)) { return -1; } total_bytes += len + 1; return 0; }
int is_ramdump(char *p) { char *x = NULL, *y = NULL, *pat; size_t len; char *pattern; int err = 0; if (nodes || !strchr(p, '@')) return 0; len = strlen(p); pattern = (char *)malloc(len + 1); strlcpy(pattern, p, len + 1); pat = pattern; while ((pat = strtok_r(pat, ",", &x))) { if ((pat = strtok_r(pat, "@", &y))) { nodes++; ramdump = realloc(ramdump, sizeof(struct ramdump_def) * nodes); if (!ramdump) error(FATAL, "realloc failure\n"); ramdump[nodes - 1].path = pat; pat = strtok_r(NULL, "@", &y); ramdump[nodes - 1].start_paddr = htoll(pat, RETURN_ON_ERROR, &err); if (err == TRUE) error(FATAL, "Invalid ramdump address\n"); if ((ramdump[nodes - 1].rfd = open(ramdump[nodes - 1].path, O_RDONLY)) < 0) error(FATAL, "ramdump %s open failed:%s\n", ramdump[nodes - 1].path, strerror(errno)); } pat = NULL; } return nodes; }
static int sync_readmode(int fd, const char* path, unsigned* mode) { syncmsg msg; int len = strlen(path); msg.req.id = ID_STAT; msg.req.namelen = htoll(len); if(!WriteFdExactly(fd, &msg.req, sizeof(msg.req)) || !WriteFdExactly(fd, path, len)) { return -1; } if(!ReadFdExactly(fd, &msg.stat, sizeof(msg.stat))) { return -1; } if(msg.stat.id != ID_STAT) { return -1; } *mode = ltohl(msg.stat.mode); return 0; }
static int write_data_file(int fd, const char *path, syncsendbuf *sbuf) { int lfd, err = 0; lfd = adb_open(path, O_RDONLY); if(lfd < 0) { fprintf(stderr,"cannot open '%s': %s\n", path, strerror(errno)); return -1; } sbuf->id = ID_DATA; for(;;) { int ret; ret = adb_read(lfd, sbuf->data, SYNC_DATA_MAX); if(!ret) break; if(ret < 0) { if(errno == EINTR) continue; fprintf(stderr,"cannot read '%s': %s\n", path, strerror(errno)); break; } sbuf->size = htoll(ret); if(writex(fd, sbuf, sizeof(unsigned) * 2 + ret)){ err = -1; break; } total_bytes += ret; STATUS(); } adb_close(lfd); return err; }
int encapsulateListIdentyResponseMessage(EIP_BYTE *pa_pacCommBuf) { EIP_UINT8 *pacCommBufRunner = pa_pacCommBuf; EIP_BYTE *acIdLenBuf; htols(1, &pacCommBufRunner); /* one item */ htols(ITEM_ID_LISTIDENTITY, &pacCommBufRunner); acIdLenBuf = pacCommBufRunner; pacCommBufRunner += 2; /*at this place the real length will be inserted below*/ htols(SUPPORTED_PROTOCOL_VERSION, &pacCommBufRunner); encapsulateIPAdress(OPENER_ETHERNET_PORT, Interface_Configuration.IPAddress, pacCommBufRunner); pacCommBufRunner += 8; memset(pacCommBufRunner, 0, 8); pacCommBufRunner += 8; htols(VendorID, &pacCommBufRunner); htols(DeviceType, &pacCommBufRunner); htols(ProductCode, &pacCommBufRunner); *(pacCommBufRunner)++ = Revison.MajorRevision; *(pacCommBufRunner)++ = Revison.MinorRevision; htols(ID_Status, &pacCommBufRunner); htoll(SerialNumber, &pacCommBufRunner); *pacCommBufRunner++ = (unsigned char) ProductName.Length; memcpy(pacCommBufRunner, ProductName.String, ProductName.Length); pacCommBufRunner += ProductName.Length; *pacCommBufRunner++ = 0xFF; htols(pacCommBufRunner - acIdLenBuf - 2, &acIdLenBuf); /* the -2 is for not counting the length field*/ return pacCommBufRunner - pa_pacCommBuf; }
int sync_recv(int fd, const char *rpath, const char *lpath) { syncmsg msg; int len; int lfd = -1; char *buffer = send_buffer.data; unsigned id; len = strlen(rpath); if(len > 1024) return -1; 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)) { sdb_unlink(lpath); mkdirs((char *)lpath); lfd = sdb_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"); sdb_close(lfd); return -1; } if(readx(fd, buffer, len)) { sdb_close(lfd); return -1; } if(writex(lfd, buffer, len)) { fprintf(stderr,"cannot write '%s': %s\n", rpath, strerror(errno)); sdb_close(lfd); return -1; } total_bytes += len; } sdb_close(lfd); return 0; remote_error: sdb_close(lfd); sdb_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; }
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; }
static int sync_send(int fd, const char *lpath, const char *rpath, unsigned mtime, mode_t mode, int show_progress) { syncmsg msg; int len, r; syncsendbuf *sbuf = &send_buffer; char* file_buffer = NULL; int size = 0; char tmp[64]; len = strlen(rpath); if(len > 1024) goto fail; snprintf(tmp, sizeof(tmp), ",%d", mode); r = strlen(tmp); msg.req.id = ID_SEND; msg.req.namelen = htoll(len + r); if(writex(fd, &msg.req, sizeof(msg.req)) || writex(fd, rpath, len) || writex(fd, tmp, r)) { free(file_buffer); goto fail; } if (file_buffer) { write_data_buffer(fd, file_buffer, size, sbuf, show_progress); free(file_buffer); } else if (S_ISREG(mode)) write_data_file(fd, lpath, sbuf, show_progress); #ifdef HAVE_SYMLINKS else if (S_ISLNK(mode)) write_data_link(fd, lpath, sbuf); #endif else goto fail; msg.data.id = ID_DONE; msg.data.size = htoll(mtime); if(writex(fd, &msg.data, sizeof(msg.data))) goto fail; if(readx(fd, &msg.status, sizeof(msg.status))) return -1; if(msg.status.id != ID_OKAY) { if(msg.status.id == ID_FAIL) { len = ltohl(msg.status.msglen); if(len > 256) len = 256; if(readx(fd, sbuf->data, len)) { return -1; } sbuf->data[len] = 0; } else strcpy(sbuf->data, "unknown reason"); fprintf(stderr,"failed to copy '%s' to '%s': %s\n", lpath, rpath, sbuf->data); return -1; } return 0; fail: fprintf(stderr,"protocol failure\n"); adb_close(fd); return -1; }
static int do_send(int s, char *path, char *buffer) { char *tmp; mode_t mode; int is_link, ret; tmp = strrchr(path,','); if(tmp) { *tmp = 0; errno = 0; mode = strtoul(tmp + 1, NULL, 0); #ifndef HAVE_SYMLINKS is_link = 0; #else is_link = S_ISLNK(mode); #endif mode &= 0777; } if(!tmp || errno) { mode = 0644; is_link = 0; } adb_unlink(path); #ifdef HAVE_SYMLINKS if(is_link) ret = handle_send_link(s, path, buffer); else { #else { #endif /* copy user permission bits to "group" and "other" permissions */ mode |= ((mode >> 3) & 0070); mode |= ((mode >> 3) & 0007); ret = handle_send_file(s, path, mode, buffer); } return ret; } static int do_recv(int s, const char *path, char *buffer) { syncmsg msg; int fd, r; fd = adb_open(path, O_RDONLY); if(fd < 0) { if(fail_errno(s)) return -1; return 0; } msg.data.id = ID_DATA; for(;;) { r = adb_read(fd, buffer, SYNC_DATA_MAX); if(r <= 0) { if(r == 0) break; if(errno == EINTR) continue; r = fail_errno(s); adb_close(fd); return r; } msg.data.size = htoll(r); if(writex(s, &msg.data, sizeof(msg.data)) || writex(s, buffer, r)) { adb_close(fd); return -1; } } adb_close(fd); msg.data.id = ID_DONE; msg.data.size = 0; if(writex(s, &msg.data, sizeof(msg.data))) { return -1; } return 0; }
static int sync_send(int fd, const char *lpath, const char *rpath, unsigned mtime, mode_t mode, int verifyApk) { syncmsg msg; int len, r; syncsendbuf *sbuf = &send_buffer; char* file_buffer = NULL; int size = 0; char tmp[64]; len = strlen(rpath); if(len > 1024) goto fail; snprintf(tmp, sizeof(tmp), ",%d", mode); r = strlen(tmp); if (verifyApk) { int lfd; zipfile_t zip; zipentry_t entry; int amt; // if we are transferring an APK file, then sanity check to make sure // we have a real zip file that contains an AndroidManifest.xml // this requires that we read the entire file into memory. lfd = adb_open(lpath, O_RDONLY); if(lfd < 0) { fprintf(stderr,"cannot open '%s': %s\n", lpath, strerror(errno)); return -1; } size = adb_lseek(lfd, 0, SEEK_END); if (size == -1 || -1 == adb_lseek(lfd, 0, SEEK_SET)) { fprintf(stderr, "error seeking in file '%s'\n", lpath); adb_close(lfd); return 1; } file_buffer = (char *)malloc(size); if (file_buffer == NULL) { fprintf(stderr, "could not allocate buffer for '%s'\n", lpath); adb_close(lfd); return 1; } amt = adb_read(lfd, file_buffer, size); if (amt != size) { fprintf(stderr, "error reading from file: '%s'\n", lpath); adb_close(lfd); free(file_buffer); return 1; } adb_close(lfd); zip = init_zipfile(file_buffer, size); if (zip == NULL) { fprintf(stderr, "file '%s' is not a valid zip file\n", lpath); free(file_buffer); return 1; } entry = lookup_zipentry(zip, "AndroidManifest.xml"); release_zipfile(zip); if (entry == NULL) { fprintf(stderr, "file '%s' does not contain AndroidManifest.xml\n", lpath); free(file_buffer); return 1; } } msg.req.id = ID_SEND; msg.req.namelen = htoll(len + r); if(writex(fd, &msg.req, sizeof(msg.req)) || writex(fd, rpath, len) || writex(fd, tmp, r)) { free(file_buffer); goto fail; } if (file_buffer) { write_data_buffer(fd, file_buffer, size, sbuf); free(file_buffer); } else if (S_ISREG(mode)) write_data_file(fd, lpath, sbuf); #ifdef HAVE_SYMLINKS else if (S_ISLNK(mode)) write_data_link(fd, lpath, sbuf); #endif else goto fail; msg.data.id = ID_DONE; msg.data.size = htoll(mtime); if(writex(fd, &msg.data, sizeof(msg.data))) goto fail; if(readx(fd, &msg.status, sizeof(msg.status))) return -1; if(msg.status.id != ID_OKAY) { if(msg.status.id == ID_FAIL) { len = ltohl(msg.status.msglen); if(len > 256) len = 256; if(readx(fd, sbuf->data, len)) { return -1; } sbuf->data[len] = 0; } else strcpy(sbuf->data, "unknown reason"); fprintf(stderr,"failed to copy '%s' to '%s': %s\n", lpath, rpath, sbuf->data); return -1; } return 0; fail: fprintf(stderr,"protocol failure\n"); adb_close(fd); return -1; }
static int write_header(int fd) { unsigned int hz=htoll(8000); unsigned int bhz = htoll(1625); unsigned int hs = htoll(20); unsigned short fmt = htols(49); unsigned short chans = htols(1); unsigned int fhs = htoll(4); unsigned int x_1 = htoll(65); unsigned short x_2 = htols(2); unsigned short x_3 = htols(320); unsigned int y_1 = htoll(20160); unsigned int size = htoll(0); /* Write a GSM header, ignoring sizes which will be filled in later */ if (write(fd, "RIFF", 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &size, 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, "WAVEfmt ", 8) != 8) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &hs, 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &fmt, 2) != 2) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &chans, 2) != 2) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &hz, 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &bhz, 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &x_1, 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &x_2, 2) != 2) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &x_3, 2) != 2) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, "fact", 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &fhs, 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &y_1, 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, "data", 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } if (write(fd, &size, 4) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } return 0; }
static int do_send(int s, char *path, char *buffer) { char *tmp; unsigned int mode; int is_link, ret; bool do_unlink; tmp = strrchr(path,','); if(tmp) { *tmp = 0; errno = 0; mode = strtoul(tmp + 1, NULL, 0); #ifndef HAVE_SYMLINKS is_link = 0; #else is_link = S_ISLNK((mode_t) mode); #endif mode &= 0777; } if(!tmp || errno) { mode = 0644; is_link = 0; do_unlink = true; } else { struct stat st; /* Don't delete files before copying if they are not "regular" */ do_unlink = lstat(path, &st) || S_ISREG(st.st_mode) || S_ISLNK(st.st_mode); if (do_unlink) { adb_unlink(path); } } #ifdef HAVE_SYMLINKS if(is_link) ret = handle_send_link(s, path, buffer); else { #else { #endif uid_t uid = -1; gid_t gid = -1; uint64_t cap = 0; /* copy user permission bits to "group" and "other" permissions */ mode |= ((mode >> 3) & 0070); mode |= ((mode >> 3) & 0007); tmp = path; if(*tmp == '/') { tmp++; } if (is_on_system(path) || is_on_vendor(path)) { fs_config(tmp, 0, &uid, &gid, &mode, &cap); } ret = handle_send_file(s, path, uid, gid, mode, buffer, do_unlink); } return ret; } static int do_recv(int s, const char *path, char *buffer) { syncmsg msg; int fd, r; fd = adb_open(path, O_RDONLY | O_CLOEXEC); if(fd < 0) { if(fail_errno(s)) return -1; return 0; } msg.data.id = ID_DATA; for(;;) { if(syc_size_enabled == 1) { r = adb_read(fd, buffer, SYNC_DATA_MAX_CUSTOMIZE); } else { r = adb_read(fd, buffer, SYNC_DATA_MAX); } if(r <= 0) { if(r == 0) break; if(errno == EINTR) continue; r = fail_errno(s); adb_close(fd); return r; } msg.data.size = htoll(r); if(writex(s, &msg.data, sizeof(msg.data)) || writex(s, buffer, r)) { adb_close(fd); return -1; } } adb_close(fd); msg.data.id = ID_DONE; msg.data.size = 0; if(writex(s, &msg.data, sizeof(msg.data))) { return -1; } return 0; }
static int write_header(FILE *f) { /* Samples per second (always 8000 for this format). */ unsigned int sample_rate = htoll(8000); /* Bytes per second (always 1625 for this format). */ unsigned int byte_sample_rate = htoll(1625); /* This is the size of the "fmt " subchunk */ unsigned int fmtsize = htoll(20); /* WAV #49 */ unsigned short fmt = htols(49); /* Mono = 1 channel */ unsigned short chans = htols(1); /* Each block of data is exactly 65 bytes in size. */ unsigned int block_align = htoll(MSGSM_FRAME_SIZE); /* Not actually 2, but rounded up to the nearest bit */ unsigned short bits_per_sample = htols(2); /* Needed for compressed formats */ unsigned short extra_format = htols(MSGSM_SAMPLES); /* This is the size of the "fact" subchunk */ unsigned int factsize = htoll(4); /* Number of samples in the data chunk */ unsigned int num_samples = htoll(0); /* Number of bytes in the data chunk */ unsigned int size = htoll(0); /* Write a GSM header, ignoring sizes which will be filled in later */ /* 0: Chunk ID */ if (fwrite("RIFF", 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 4: Chunk Size */ if (fwrite(&size, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 8: Chunk Format */ if (fwrite("WAVE", 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 12: Subchunk 1: ID */ if (fwrite("fmt ", 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 16: Subchunk 1: Size (minus 8) */ if (fwrite(&fmtsize, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 20: Subchunk 1: Audio format (49) */ if (fwrite(&fmt, 1, 2, f) != 2) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 22: Subchunk 1: Number of channels */ if (fwrite(&chans, 1, 2, f) != 2) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 24: Subchunk 1: Sample rate */ if (fwrite(&sample_rate, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 28: Subchunk 1: Byte rate */ if (fwrite(&byte_sample_rate, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 32: Subchunk 1: Block align */ if (fwrite(&block_align, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 36: Subchunk 1: Bits per sample */ if (fwrite(&bits_per_sample, 1, 2, f) != 2) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 38: Subchunk 1: Extra format bytes */ if (fwrite(&extra_format, 1, 2, f) != 2) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 40: Subchunk 2: ID */ if (fwrite("fact", 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 44: Subchunk 2: Size (minus 8) */ if (fwrite(&factsize, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 48: Subchunk 2: Number of samples */ if (fwrite(&num_samples, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 52: Subchunk 3: ID */ if (fwrite("data", 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } /* 56: Subchunk 3: Size */ if (fwrite(&size, 1, 4, f) != 4) { ast_log(LOG_WARNING, "Unable to write header\n"); return -1; } return 0; }
// sample rate 8000, 12000, 16000, 24000 int wav_write_header(FILE *f, int samplerate, int stereo) { unsigned int hz=htoll(samplerate); unsigned int bhz = htoll(samplerate*2*(stereo ? 2 : 1)); // 2 bytes per sample and 2 channels unsigned int hs = htoll(16); // 16bit unsigned short fmt = htols(1); unsigned short chans = htols((stereo ? 2 : 1)); unsigned short bysam = htols(2*(stereo ? 2 : 1)); unsigned short bisam = htols(16); unsigned int size = htoll(0); /* Write a wav header, ignoring sizes which will be filled in later */ fseek(f,0,SEEK_SET); if (fwrite("RIFF", 1, 4, f) != 4) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&size, 1, 4, f) != 4) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite("WAVEfmt ", 1, 8, f) != 8) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&hs, 1, 4, f) != 4) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&fmt, 1, 2, f) != 2) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&chans, 1, 2, f) != 2) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&hz, 1, 4, f) != 4) { ///log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&bhz, 1, 4, f) != 4) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&bysam, 1, 2, f) != 2) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&bisam, 1, 2, f) != 2) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite("data", 1, 4, f) != 4) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } if (fwrite(&size, 1, 4, f) != 4) { //log(LOG_WARNING, "Unable to write header\n"); return -1; } return 0; }