//==============================================================================
void CC_UnitDriver::flash_read_near(uint16_t address, size_t size, ByteVector &data)
{
const uint8_t load_dtpr[] = { 0xBE, 0x57, 0x90, HIBYTE(address), LOBYTE(address) };
usb_device_.bulk_write(endpoint_out_, sizeof(load_dtpr), load_dtpr);
size_t offset = data.size();
data.resize(offset + size, FLASH_EMPTY_BYTE);
ByteVector command;
for (size_t i = 0; i < size / FLASH_READ_CHUNK_SIZE; i++)
{
if (command.empty())
create_read_proc(FLASH_READ_CHUNK_SIZE, command);
usb_device_.bulk_write(endpoint_out_, command.size(), &command[0]);
usb_device_.bulk_read(endpoint_in_, FLASH_READ_CHUNK_SIZE, &data[offset]);
offset += FLASH_READ_CHUNK_SIZE;
pw_.read_progress(FLASH_READ_CHUNK_SIZE);
}
if ((size % FLASH_READ_CHUNK_SIZE))
{
create_read_proc(size % FLASH_READ_CHUNK_SIZE, command);
usb_device_.bulk_write(endpoint_out_, command.size(), &command[0]);
usb_device_.bulk_read(endpoint_in_, size - offset, &data[offset]);
pw_.read_progress(size - offset);
}
}
//==============================================================================
void CC_UnitDriver::flash_read_32k(size_t address, size_t size, ByteVector &data)
{
if (((address % 0x8000) + size) > 0x8000)
throw std::runtime_error("flash_read_32k, incorrect parameters");
const uint8_t load_dtpr[] = { 0xBE, 0x57, 0x90, address >> 8, address };
usb_device_.bulk_write(ENDPOINT_OUT, sizeof(load_dtpr), load_dtpr);
size_t offset = data.size();
data.resize(offset + size, 0xFF);
ByteVector command;
for (size_t i = 0; i < size / FLASH_READ_CHUNK_SIZE; i++)
{
if (command.empty())
create_read_proc(FLASH_READ_CHUNK_SIZE, command);
usb_device_.bulk_write(ENDPOINT_OUT, command.size(), &command[0]);
usb_device_.bulk_read(ENDPOINT_IN, FLASH_READ_CHUNK_SIZE, &data[offset]);
offset += FLASH_READ_CHUNK_SIZE;
pw_.read_progress(FLASH_READ_CHUNK_SIZE);
}
if ((size % FLASH_READ_CHUNK_SIZE))
{
create_read_proc(size % FLASH_READ_CHUNK_SIZE, command);
usb_device_.bulk_write(ENDPOINT_OUT, command.size(), &command[0]);
usb_device_.bulk_read(ENDPOINT_IN, size - offset, &data[offset]);
pw_.read_progress(size - offset);
}
}
/*----------------------------------------------------------------------------*/
bool DDAProtocol :: txPacket()
{
ByteVector txData;
if(m_txData.size())
txData = m_txData[0];
if(txData.empty())
return false;
unsigned size = txData.size();
serial_write(m_serial, &txData.at(0), size);
return true;
}
bool CHttpServer::receive_request(ByteVector &request)
{
if (verbose) RAWTRACE("Receiving request...");
ByteVector r;
char buf[BUF_SIZE];
int attempts = 0;
for(;;) {
if (verbose) RAWTRACE("Read portion of data from socket...");
int n = recv(m_sock, &buf[0], sizeof(buf), 0);
//RAWTRACE1("RECV: %d", n);
if (n == -1) {
int e = RHO_NET_ERROR_CODE;
if (verbose) RAWTRACE1("RECV ERROR: %d", e);
#if !defined(WINDOWS_PLATFORM)
if (e == EINTR)
continue;
#else
if (e == WSAEINTR)
continue;
#endif
#if defined(OS_WP8) || (defined(RHODES_QT_PLATFORM) && defined(OS_WINDOWS_DESKTOP)) || defined(OS_WINCE)
if (e == EAGAIN || e == WSAEWOULDBLOCK) {
#else
if (e == EAGAIN) {
#endif
if (!r.empty())
break;
if(++attempts > (HTTP_EAGAIN_TIMEOUT*10))
{
if (verbose) RAWLOG_ERROR("Error when receiving data from socket. Client does not send data for " HTTP_EAGAIN_TIMEOUT_STR " sec. Cancel recieve.");
return false;
}
fd_set fds;
FD_ZERO(&fds);
FD_SET(m_sock, &fds);
timeval tv = {0};
tv.tv_usec = 100000;//100 MS
select(m_sock + 1, &fds, 0, 0, &tv);
continue;
}
if (verbose) RAWLOG_ERROR1("Error when receiving data from socket: %d", e);
return false;
}
if (n == 0) {
if(!r.empty()) {
if (verbose) RAWTRACE("Client closed connection gracefully");
break;
} else {
if (verbose) RAWLOG_ERROR("Connection gracefully closed before we receive any data");
return false;
}
} else {
if (verbose) RAWTRACE1("Actually read %d bytes", n);
r.insert(r.end(), &buf[0], &buf[0] + n);
}
}
if (!r.empty()) {
request.insert(request.end(), r.begin(), r.end());
if ( !rho_conf_getBool("log_skip_post") ) {
String strRequest(request.begin(),request.end());
if (verbose) RAWTRACE1("Received request:\n%s", strRequest.c_str());
}
}
return true;
}
bool CHttpServer::send_response_impl(String const &data, bool continuation)
{
#ifdef OS_MACOSX
if ( m_localResponseWriter != 0 ) {
m_localResponseWriter->writeResponse( data );
return true;
}
#endif
if (verbose) {
if (continuation)
if (verbose) RAWTRACE("Send continuation data...");
else
if (verbose) RAWTRACE("Sending response...");
}
// First of all, make socket blocking
#if defined(WINDOWS_PLATFORM)
unsigned long optval = 0;
if(::ioctlsocket(m_sock, FIONBIO, &optval) == SOCKET_ERROR) {
RAWLOG_ERROR1("Can not set blocking socket mode: %d", RHO_NET_ERROR_CODE);
return false;
}
#else
int flags = fcntl(m_sock, F_GETFL);
if (flags == -1) {
if (verbose) RAWLOG_ERROR1("Can not get current socket mode: %d", errno);
return false;
}
if (fcntl(m_sock, F_SETFL, flags & ~O_NONBLOCK) == -1) {
if (verbose) RAWLOG_ERROR1("Can not set blocking socket mode: %d", errno);
return false;
}
#endif
size_t pos = 0;
for(; pos < data.size();) {
int n = send(m_sock, data.c_str() + pos, data.size() - pos, 0);
if (n == -1) {
int e = RHO_NET_ERROR_CODE;
#if !defined(WINDOWS_PLATFORM)
if (e == EINTR)
continue;
#endif
if (verbose) RAWLOG_ERROR1("Can not send response data: %d", e);
return false;
}
if (n == 0)
break;
pos += n;
}
//String dbg_response = response.size() > 100 ? response.substr(0, 100) : response;
//RAWTRACE2("Sent response:\n%s%s", dbg_response.c_str(), response.size() > 100 ? "..." : " ");
if (continuation) {
if (verbose) RAWTRACE1("Sent response body: %d bytes", data.size());
}
else if ( !rho_conf_getBool("log_skip_post") ) {
if (verbose) RAWTRACE1("Sent response (only headers displayed):\n%s", data.c_str());
}
return true;
}
bool CHttpServer::send_response(String const &response, bool redirect)
{
#ifdef OS_ANDROID
if (redirect) {
CAutoPtr<IRhoThreadImpl> ptrThread = rho_get_RhoClassFactory()->createThreadImpl();
ptrThread->sleep(20);
}
#endif
return send_response_impl(response, false);
}
String CHttpServer::create_response(String const &reason)
{
return create_response(reason, "");
}
String CHttpServer::create_response(String const &reason, HeaderList const &headers)
{
return create_response(reason, headers, "");
}
String CHttpServer::create_response(String const &reason, String const &body)
{
return create_response(reason, HeaderList(), body);
}
String CHttpServer::create_response(String const &reason, HeaderList const &hdrs, String const &body)
{
String response = "HTTP/1.1 ";
response += reason;
response += "\r\n";
char buf[50];
snprintf(buf, sizeof(buf), "%d", m_port);
HeaderList headers;
headers.push_back(Header("Host", String("127.0.0.1:") + buf));
headers.push_back(Header("Connection", "close"));
headers.push_back(HttpHeader("Access-Control-Allow-Origin", "*"));
std::copy(hdrs.begin(), hdrs.end(), std::back_inserter(headers));
for(HeaderList::const_iterator it = headers.begin(), lim = headers.end();
it != lim; ++it) {
response += it->name;
response += ": ";
response += it->value;
response += "\r\n";
}
response += "\r\n";
response += body;
return response;
}
