/* 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;
}
