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); }