/**
**************************************************************************
*
* \brief Process the "post" command.
*
**************************************************************************
*/
static bool
ProcessCmdPost(int sd, // IN
char *data, // IN
int dataSize) // IN
{
MsgHdr req, reply;
memset(&req, 0, sizeof req);
req.type = MSG_POST;
req.dataSize = dataSize;
if (WriteFully(sd, &req, sizeof req) <= 0) {
return false;
}
if (WriteFully(sd, data, dataSize) <= 0) {
return false;
}
if (ReadFully(sd, &reply, sizeof reply) <= 0) {
return false;
}
if (reply.type != MSG_STATUS) {
Error("Unexpected reply message type %d\n", reply.type);
return false;
}
return false;
}
/**
**************************************************************************
*
* \brief Process the "show" command.
*
**************************************************************************
*/
static bool
ProcessCmdShow(int sd, // IN
char *data, // IN
int dataSize) // IN
{
MsgHdr req, reply;
memset(&req, 0, sizeof req);
req.type = MSG_SHOW;
if (WriteFully(sd, &req, sizeof req) <= 0) {
return false;
}
if (ReadFully(sd, &reply, sizeof reply) <= 0) {
return false;
}
if (reply.type != MSG_BOARD) {
Error("Unexpected reply message type %d\n", reply.type);
return false;
}
while (reply.dataSize > 0) {
char ch;
if (ReadFully(sd, &ch, sizeof ch) <= 0) {
return false;
}
printf("%c", ch);
reply.dataSize--;
}
return false;
}
static void LoadFirmware(const Uevent& uevent, const std::string& root, int fw_fd, size_t fw_size,
int loading_fd, int data_fd) {
// Start transfer.
WriteFully(loading_fd, "1", 1);
// Copy the firmware.
int rc = sendfile(data_fd, fw_fd, nullptr, fw_size);
if (rc == -1) {
PLOG(ERROR) << "firmware: sendfile failed { '" << root << "', '" << uevent.firmware
<< "' }";
}
// Tell the firmware whether to abort or commit.
const char* response = (rc != -1) ? "0" : "-1";
WriteFully(loading_fd, response, strlen(response));
}
/*----------------------------------------------------------------------
| NPT_OutputStream::WriteLine
+---------------------------------------------------------------------*/
NPT_Result
NPT_OutputStream::WriteLine(const char* buffer)
{
NPT_CHECK(WriteString(buffer));
NPT_CHECK(WriteFully((const void*)"\r\n", 2));
return NPT_SUCCESS;
}
void notifyHostBootComplete() {
if (s_QemuMiscPipe < 0) {
s_QemuMiscPipe = qemu_pipe_open(QEMU_MISC_PIPE);
if (s_QemuMiscPipe < 0) {
ALOGE("failed to open %s", QEMU_MISC_PIPE);
return;
}
}
char set[] = "bootcomplete";
int pipe_command_length = sizeof(set);
WriteFully(s_QemuMiscPipe, &pipe_command_length, sizeof(pipe_command_length));
WriteFully(s_QemuMiscPipe, set, pipe_command_length);
ReadFully(s_QemuMiscPipe, &pipe_command_length, sizeof(pipe_command_length));
if (pipe_command_length > sizeof(set) || pipe_command_length <= 0)
return;
ReadFully(s_QemuMiscPipe, set, pipe_command_length);
}
status_t PrivacyBuffer::flush(int fd) {
status_t err = NO_ERROR;
EncodedBuffer::iterator iter = size() == mData.size() ? mData : mProto.data();
while (iter.readBuffer() != NULL) {
err = WriteFully(fd, iter.readBuffer(), iter.currentToRead()) ? NO_ERROR : -errno;
iter.rp()->move(iter.currentToRead());
if (err != NO_ERROR) return err;
}
return NO_ERROR;
}
NS_IMETHODIMP
nsBinaryOutputStream::WriteStringZ(const char *aString)
{
PRUint32 length;
nsresult rv;
length = strlen(aString);
rv = Write32(length);
if (NS_FAILED(rv)) return rv;
return WriteFully(aString, length);
}
/*----------------------------------------------------------------------
| NPT_OutputStream::WriteString
+---------------------------------------------------------------------*/
NPT_Result
NPT_OutputStream::WriteString(const char* buffer)
{
// shortcut
NPT_Size string_length;
if (buffer == NULL || (string_length = NPT_StringLength(buffer)) == 0) {
return NPT_SUCCESS;
}
// write the string
return WriteFully((const void*)buffer, string_length);
}
status_t HeaderSection::Execute(ReportRequestSet* requests) const {
for (ReportRequestSet::iterator it = requests->begin(); it != requests->end(); it++) {
const sp<ReportRequest> request = *it;
const vector<vector<uint8_t>>& headers = request->args.headers();
for (vector<vector<uint8_t>>::const_iterator buf = headers.begin(); buf != headers.end();
buf++) {
if (buf->empty()) continue;
// So the idea is only requests with negative fd are written to dropbox file.
int fd = request->fd >= 0 ? request->fd : requests->mainFd();
write_section_header(fd, id, buf->size());
WriteFully(fd, (uint8_t const*)buf->data(), buf->size());
// If there was an error now, there will be an error later and we will remove
// it from the list then.
}
}
return NO_ERROR;
}
static inline bool WriteExactly(int fd, const void* buf, size_t count) {
return WriteFully(fd, buf, count) == count;
}
NS_IMETHODIMP
nsBinaryOutputStream::Write32(PRUint32 a32)
{
a32 = NS_SWAP32(a32);
return WriteFully((const char*)&a32, sizeof a32);
}
NS_IMETHODIMP
nsBinaryOutputStream::Write16(PRUint16 a16)
{
a16 = NS_SWAP16(a16);
return WriteFully((const char*)&a16, sizeof a16);
}
NS_IMETHODIMP
nsBinaryOutputStream::Write8(PRUint8 aByte)
{
return WriteFully((const char*)&aByte, sizeof aByte);
}
NS_IMETHODIMP
nsBinaryOutputStream::Write32(uint32_t a32)
{
a32 = mozilla::NativeEndian::swapToBigEndian(a32);
return WriteFully((const char*)&a32, sizeof a32);
}
NS_IMETHODIMP
nsBinaryOutputStream::Write16(uint16_t a16)
{
a16 = mozilla::NativeEndian::swapToBigEndian(a16);
return WriteFully((const char*)&a16, sizeof a16);
}
