void Socket::Close(void)
{
close(GetFD());
shutdown(GetFD(),SHUT_RDWR);
open = false;
terminator.Trigger();
}
Socket & Socket::operator=(Socket const & rhs)
{
close(GetFD());
socketDescriptor = rhs.socketDescriptor;
SetFD(dup(rhs.GetFD()));
open = rhs.open;
}
int Socket::Read(ByteArray & buffer)
{
char raw[MAX_BUFFER_SIZE];
if (!open)
return 0;
buffer.v.clear();
// Allow interruption of block.
FlexWait waiter(2,this,&terminator);
Blockable * result = waiter.Wait();
// This happens if the call was shutdown on this side
if (result == &terminator)
{
terminator.Reset();
return 0;
}
// If we got here, we need to read the socket
// Messages greater than MAX_BUFFER_SIZE are not handled gracefully.
ssize_t received = recv(GetFD(), raw, MAX_BUFFER_SIZE, 0);
for (int i=0;i<received;i++)
buffer.v.push_back(raw[i]);
if (received <=0)
open = false;
return received;
}
int Socket::Open(void)
{
int connectReturn = connect(GetFD(),(sockaddr*)&socketDescriptor,sizeof(socketDescriptor));
if (connectReturn != 0)
{
throw std::string("Unable to open connection");
}
open = true;
}
////////////////////////////////////////////////////////////////////////
/// SSLSocket
////////////////////////////////////////////////////////////////////////
SSLSocket::SSLSocket()
{
ctx = SSLContext::GetContext()->CreateSSLCtx();
ssl = SSL_new(ctx);
if(ssl != NULL)
{
SSL_set_fd(ssl, GetFD());
}
}
SSLSocket::SSLSocket(const std::string& ip, short port)
: Socket(ip, port)
{
ctx = SSLContext::GetContext()->CreateSSLCtx();
ssl = SSL_new(ctx);
if(ssl != NULL)
{
SSL_set_fd(ssl, GetFD());
}
}
int Socket::Write(ByteArray const & buffer)
{
if (!open)
return -1;
char * raw = new char[buffer.v.size()];
for (int i=0;i<buffer.v.size();i++)
raw[i] = buffer.v[i];
int returnValue = write(GetFD(),raw,buffer.v.size());
if (returnValue <=0)
open = false;
return returnValue;
}
// GetStat
status_t
NodeHandle::GetStat(struct stat* st)
{
int fd = GetFD();
if (fd < 0)
return B_ENTRY_NOT_FOUND;
if (fstat(fd, st) < 0)
return errno;
return B_OK;
}
static struct file_descriptor*
get_fd_locked(struct io_context* context, int fd)
{
if (fd < 0 || (uint32)fd >= context->table_size)
return NULL;
struct file_descriptor* descriptor = context->fds[fd];
if (descriptor != NULL) {
TFD(GetFD(context, fd, descriptor));
inc_fd_ref_count(descriptor);
}
return descriptor;
}
void SelectServerFrame::Run() {
if (m_sock_server_ptr->Start()) {
int max_fd = 0;
fd_set master_read_fds; // master file descriptor list
fd_set temp_read_fds; // temp file descriptor list for select()
// clear the master and temp sets
FD_ZERO(&master_read_fds);
FD_ZERO(&temp_read_fds);
auto listener_fd = m_sock_server_ptr->GetFD();
//add the listener to the master read FD set
FD_SET(listener_fd, &master_read_fds);
max_fd = listener_fd + 1;
for (;;) {
temp_read_fds = master_read_fds;
if (select(max_fd, &temp_read_fds, NULL, NULL, NULL) == -1) {
std::cerr << "Error select." << std::endl;
break;
}
//Handle listener
if (FD_ISSET(listener_fd, &temp_read_fds)) {
auto remote_endpoint_ptr = m_sock_server_ptr->HandleAccept();
if (remote_endpoint_ptr) {
auto remote_fd = remote_endpoint_ptr->GetFD();
m_remote_endpoints[remote_fd] = std::move(remote_endpoint_ptr);
//add to master set
FD_SET(remote_fd, &master_read_fds);
if (remote_fd >= max_fd) {
max_fd = remote_fd + 1;
}
}
}
//Handle remote points
for (auto iter = m_remote_endpoints.begin(); iter != m_remote_endpoints.end();) {
if (FD_ISSET(iter->first, &temp_read_fds)) {
if (!iter->second->RunOnce()) {
FD_CLR(iter->first, &master_read_fds);
iter = m_remote_endpoints.erase(iter);
continue;
}
}
++iter;
}
}
}
}
Socket::Socket(std::string const & ipAddress, unsigned int port)
: Blockable(),open(false)
{
// First, call socket() to get a socket file descriptor
SetFD(socket(AF_INET, SOCK_STREAM, 0));
if (GetFD() < 0)
throw std::string("Unable to initialize socket server");
// Start by zeroing out the socket descriptor
bzero((char*)&socketDescriptor,sizeof(sockaddr_in));
// Now try to map the IP address, as provided, into the socket Descriptor
if (!inet_aton(ipAddress.c_str(),&socketDescriptor.sin_addr))
throw std::string("IP Address provided is invalid");
socketDescriptor.sin_family = AF_INET;
socketDescriptor.sin_port = htons(port);
}
static struct file_descriptor*
get_fd_locked(struct io_context* context, int fd)
{
if (fd < 0 || (uint32)fd >= context->table_size)
return NULL;
struct file_descriptor* descriptor = context->fds[fd];
if (descriptor != NULL) {
// Disconnected descriptors cannot be accessed anymore
if (descriptor->open_mode & O_DISCONNECTED)
descriptor = NULL;
else {
TFD(GetFD(context, fd, descriptor));
inc_fd_ref_count(descriptor);
}
}
return descriptor;
}
Socket SocketServer::Accept(void)
{
FlexWait waiter(2,this,&terminator);
Blockable * result = waiter.Wait();
if (result == &terminator)
{
terminator.Reset();
throw TerminationException(2);
}
if (result == this)
{
int connectionFD = accept(GetFD(),NULL,0);
if (connectionFD < 0)
{
throw std::string("Unexpected error in the server");
}
return Socket(connectionFD);
}
else
throw std::string("Unexpected error in the server");
}
enumError ReadWDF ( SuperFile_t * sf, off_t off, void * buf, size_t count )
{
ASSERT(sf);
ASSERT(sf->wc);
ASSERT(sf->wc_used);
TRACE("#W# -----\n");
TRACE(TRACE_RDWR_FORMAT, "#W# ReadWDF()",
GetFD(&sf->f), GetFP(&sf->f), (u64)off, (u64)off+count, count, "" );
if ( off + count > sf->wh.file_size )
{
if (!sf->f.read_behind_eof)
{
if ( !sf->f.disable_errors )
ERROR0( ERR_READ_FAILED, "Read behind eof [%c,%llx+%zx]: %s\n",
sf->f.fp ? 'S' : sf->f.fd != -1 ? 'F' : '-',
(u64)off, count, sf->f.fname );
return ERR_READ_FAILED;
}
const off_t max_read = sf->wh.file_size > off
? sf->wh.file_size - off
: 0;
ASSERT( count > max_read );
if ( sf->f.read_behind_eof == 1 )
{
sf->f.read_behind_eof = 2;
if ( !sf->f.disable_errors )
ERROR0( ERR_WARNING, "Read behind eof -> zero filled [%c,%llx+%zx]: %s\n",
sf->f.fp ? 'S' : sf->f.fd != -1 ? 'F' : '-',
(u64)off, count, sf->f.fname );
}
size_t fill_count = count - (size_t)max_read;
count = (size_t)max_read;
memset((char*)buf+count,0,fill_count);
if (!count)
return ERR_OK;
}
// find chunk header
WDF_Chunk_t * wc = sf->wc;
const int used_m1 = sf->wc_used - 1;
int beg = 0, end = used_m1;
ASSERT( beg <= end );
while ( beg < end )
{
int idx = (beg+end)/2;
wc = sf->wc + idx;
if ( off < wc->file_pos )
end = idx-1;
else if ( idx < used_m1 && off >= wc[1].file_pos )
beg = idx + 1;
else
beg = end = idx;
}
wc = sf->wc + beg;
noTRACE("#W# - FOUND #%03d: off=%09llx ds=%llx, off=%09llx\n",
beg, wc->file_pos, wc->data_size, (u64)off );
ASSERT( off >= wc->file_pos );
ASSERT( beg == used_m1 || off < wc[1].file_pos );
char * dest = buf;
while ( count > 0 )
{
noTRACE("#W# %d/%d count=%zd off=%llx,%llx \n",
beg, sf->wc_used, count, (u64)off, (u64)wc->file_pos );
if ( off < wc->file_pos )
{
const u64 max_size = wc->file_pos - off;
const u32 fill_size = max_size < count ? (u32)max_size : count;
TRACE("#W# >FILL %p +%8zx = %p .. %x\n",
buf, dest-(ccp)buf, dest, fill_size );
memset(dest,0,fill_size);
count -= fill_size;
off += fill_size;
dest += fill_size;
if (!count)
break;
}
if ( off >= wc->file_pos && off < wc->file_pos + wc->data_size )
{
// we want a part of this
const u64 delta = off - wc->file_pos;
const u64 max_size = wc->data_size - delta;
const u32 read_size = max_size < count ? (u32)max_size : count;
TRACE("#W# >READ %p +%8zx = %p .. %x <- %10llx\n",
buf, dest-(ccp)buf, dest, read_size, wc->data_off+delta );
int stat = ReadAtF(&sf->f,wc->data_off+delta,dest,read_size);
if (stat)
return stat;
count -= read_size;
off += read_size;
dest += read_size;
if (!count)
break;
}
wc++;
if ( ++beg >= sf->wc_used )
{
TRACE("ERR_WDF_INVALID\n");
return ERR_WDF_INVALID;
}
}
TRACE("#W# - done, dest = %p\n",dest);
return ERR_OK;
}
IndexServerConn::~IndexServerConn()
{
close(GetFD());
}
enumError WriteWDF ( SuperFile_t * sf, off_t off, const void * buf, size_t count )
{
ASSERT(sf);
ASSERT(sf->wc);
TRACE("#W# -----\n");
TRACE(TRACE_RDWR_FORMAT, "#W# WriteWDF()",
GetFD(&sf->f), GetFP(&sf->f), (u64)off, (u64)off+count, count,
off < sf->max_virt_off ? " <" : "" );
TRACE(" - off = %llx,%llx, fs = %llx\n",
(u64)sf->f.file_off, (u64)sf->f.max_off, (u64)sf->file_size );
if (!count)
return ERR_OK;
// adjust the file size
const off_t data_end = off + count;
if ( sf->file_size < data_end )
sf->file_size = data_end;
ASSERT( sf->wc_used > 0 );
const int used_m1 = sf->wc_used - 1;
if ( off >= sf->max_virt_off )
{
// SPECIAL CASE:
// the current virtual file will be extended
// -> no need to search chunks
if ( off <= sf->max_virt_off + WDF_MIN_HOLE_SIZE )
{
// maybe an extend of the last chunk -> get the last chunk
WDF_Chunk_t * wc = sf->wc + used_m1;
if ( wc->data_off + wc->data_size == sf->f.max_off )
{
// yes, it is the last written chunk
const u32 skip = off - sf->max_virt_off;
// adjust max_virt_off
sf->max_virt_off = off + count;
const enumError err
= WriteAtF(&sf->f,skip+wc->data_off+wc->data_size,buf,count);
wc->data_size += skip + count;
return err;
}
}
// adjust max_virt_off
sf->max_virt_off = off + count;
// create a new chunk at end of file
WDF_Chunk_t * wc = NeedChunkWDF(sf,sf->wc_used);
wc->file_pos = off;
wc->data_off = sf->f.max_off;
wc->data_size = count;
return WriteAtF(&sf->f,wc->data_off,buf,count);
}
// search chunk header with a binary search
WDF_Chunk_t * wc = sf->wc;
int beg = 0, end = used_m1;
ASSERT( beg <= end );
while ( beg < end )
{
int idx = (beg+end)/2;
wc = sf->wc + idx;
if ( off < wc->file_pos )
end = idx-1;
else if ( idx < used_m1 && off >= wc[1].file_pos )
beg = idx + 1;
else
beg = end = idx;
}
wc = sf->wc + beg;
TRACE("#W# - FOUND #%03d: off=%09llx ds=%llx, off=%09llx\n",
beg, wc->file_pos, wc->data_size, (u64)off );
ASSERT( off >= wc->file_pos );
ASSERT( beg == used_m1 || off < wc[1].file_pos );
ccp src = buf;
while ( count > 0 )
{
TRACE("#W# %d/%d count=%zd off=%llx,%llx \n",
beg, sf->wc_used, count, (u64)off, wc->file_pos );
if ( off < wc->file_pos )
{
const u64 max_size = wc->file_pos - off;
const u32 wr_size = max_size < count ? (u32)max_size : count;
TRACE("#W# >CREATE#%02d %p +%8zx = %10llx .. +%4x\n",
beg, buf, src-(ccp)buf, (u64)off, wr_size );
// create a new chunk
wc = NeedChunkWDF(sf,beg);
wc->file_pos = off;
wc->data_off = sf->f.max_off;
wc->data_size = wr_size;
// write data & return
const enumError stat = WriteAtF(&sf->f,wc->data_off,src,wr_size);
if (stat)
return stat;
wc++;
beg++;
count -= wr_size;
off += wr_size;
src += wr_size;
if (!count)
break;
}
if ( off >= wc->file_pos && off < wc->file_pos + wc->data_size )
{
// we want a part of this
const u64 delta = off - wc->file_pos;
const u64 max_size = wc->data_size - delta;
const u32 wr_size = max_size < count ? (u32)max_size : count;
TRACE("#W# >OVERWRITE#%02d %p +%8zx = %10llx .. +%4x, delta=%lld\n",
beg, buf, src-(ccp)buf, (u64)off, wr_size, delta );
const enumError stat = WriteAtF(&sf->f,wc->data_off+delta,src,wr_size);
if (stat)
return stat;
count -= wr_size;
off += wr_size;
src += wr_size;
if (!count)
break;
}
wc++;
if ( ++beg >= sf->wc_used )
return WriteWDF(sf,off,src,count);
}
return ERR_OK;
}
enumError WriteZeroWDF ( SuperFile_t * sf, off_t off, size_t count )
{
ASSERT(sf);
ASSERT(sf->wc);
TRACE("#W# -----\n");
TRACE(TRACE_RDWR_FORMAT, "#W# WriteZeroWDF()",
GetFD(&sf->f), GetFP(&sf->f), (u64)off, (u64)off+count, count,
off < sf->max_virt_off ? " <" : "" );
TRACE(" - off = %llx,%llx,%llx\n",
(u64)sf->f.file_off, (u64)sf->f.max_off, (u64)sf->max_virt_off);
if (!count)
return ERR_OK;
// adjust the file size
const off_t data_end = off + count;
if ( sf->file_size < data_end )
sf->file_size = data_end;
ASSERT( sf->wc_used > 0 );
const int used_m1 = sf->wc_used - 1;
if ( off >= sf->max_virt_off )
return ERR_OK;
// search chunk header with a binary search
WDF_Chunk_t * wc = sf->wc;
int beg = 0, end = used_m1;
ASSERT( beg <= end );
while ( beg < end )
{
int idx = (beg+end)/2;
wc = sf->wc + idx;
if ( off < wc->file_pos )
end = idx-1;
else if ( idx < used_m1 && off >= wc[1].file_pos )
beg = idx + 1;
else
beg = end = idx;
}
wc = sf->wc + beg;
TRACE("#W# - FOUND #%03d: off=%09llx ds=%llx, off=%09llx\n",
beg, wc->file_pos, wc->data_size, (u64)off );
ASSERT( off >= wc->file_pos );
ASSERT( beg == used_m1 || off < wc[1].file_pos );
WDF_Chunk_t * last_wc = sf->wc + sf->wc_used;
for ( ; wc < last_wc || wc->file_pos < data_end; wc++ )
{
off_t end = wc->file_pos + wc->data_size;
TRACE("loop: wc=%llx,%llx,%llx off=%llx, end=%llx\n",
wc->file_pos, wc->data_off, wc->data_size, (u64)off, (u64)end );
if ( off >= end )
continue;
if ( off < wc->file_pos )
off = wc->file_pos;
if ( end > data_end )
end = data_end;
if ( off < end )
{
const enumError err
= WriteZeroAtF( &sf->f, wc->data_off+(off-wc->file_pos), end-off );
if (err)
return err;
}
}
return ERR_OK;
}
void VOD_SessionControl::ReadSessionSocketCallback(int32_t fd, int16_t event, void *arg)
{
FNLOG(DL_MSP_ONDEMAND);
UNUSED_PARAM(fd)
UNUSED_PARAM(event)
UNUSED_PARAM(arg)
uint8_t *msgData = NULL;
uint32_t msgLen = 0;
VodDsmcc_Base *dsmccObj = NULL;
LOG(DLOGL_NOISE, " session response received on fd:%d ", fd);
int sockFd = GetFD();
if (sockFd != -1)
{
bool readStatus = VodDsmcc_Base::ReadMessageFromSocket(sockFd, &msgData,
&msgLen);
if (readStatus)
{
LOG(DLOGL_NORMAL, "%s:%d msgLen:%d ", __FUNCTION__, __LINE__, msgLen);
//get dsmcc response message type
dsmccObj = VodDsmcc_Base::GetMessageTypeObject(msgData, msgLen);
if (dsmccObj)
{
//parse dsmcc response
status parseStatus = dsmccObj->ParseDsmccMessageBody(msgData, msgLen);
if (parseStatus == E_TRUE)
{
LOG(DLOGL_REALLY_NOISY, "DSMCC- message id:%x : transId %x ", dsmccObj->GetMessageId(), dsmccObj->GetTransactionId());
bool found = false;
unsigned int sessId = VOD_SessionControl::getSessionNumber(dsmccObj);
ActiveVodSessionMap::iterator itr;
for (itr = mActiveVodSessionMap.begin(); itr != mActiveVodSessionMap.end(); ++itr)
{
LOG(DLOGL_NOISE, " itr->first %d ", itr->first);
if (itr->first == sessId)
{
found = true;
break;
}
}
LOG(DLOGL_NOISE, "sessId: %d found: %d", sessId, found);
if (found)
{
itr->second->handleReadSessionData(dsmccObj);
}
}
else
{
LOG(DLOGL_ERROR, " ParseDsmccMessageBody failed");
}
}
}
else
{
LOG(DLOGL_ERROR, "warning ReadMessageFromSocket failed");
}
}
else
{
LOG(DLOGL_ERROR, "Invalid sockFd ");
}
}
SocketServer::~SocketServer(void)
{
close(GetFD());
//shutdown(GetFD(),SHUT_RDWR);
}
