Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/sockets__man_8cpp_source.html below:

NCBI C++ ToolKit: src/app/netcache/sockets_man.cpp Source File

&CSrvSocketTask::m_SockListHook> TSockListHookOpt;

intr::constant_time_size<false> >

;

intr::base_hook<TSrvSockListHook>,

std::list<CSrvSocketTask*>

;

is(

), eol(

);

* err_msg,

* errno_str,

<< err_msg <<

<< x_errno <<

<< errno_str <<

;

* err_msg,

* err_msg,

res = fcntl(sock, F_SETFL, O_NONBLOCK);

res = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &

,

(

));

res = setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &

,

(

));

res = setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, &

,

(

));

sock = socket(AF_INET, SOCK_STREAM, 0);

res = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &

,

(

));

sockaddr_in

;

memset(&

, 0,

(

));

.sin_family = AF_INET;

.sin_port = htons(sock_info.

);

res = bind(sock, (

sockaddr*)&

,

(

));

err_msg(

);

res = listen(sock, 128);

epoll_event evt;

evt.events =

| EPOLLET;

evt.data.ptr = (

*)&sock_info;

res = epoll_ctl(

, EPOLL_CTL_ADD, sock, &evt);

sock_info.

= sock;

res = getsockopt(fd, SOL_SOCKET, SO_ERROR, &x_errno, &

);

res = setsockopt(fd, SOL_SOCKET, SO_LINGER, (

*)&

,

(

));

res = setsockopt(fd, IPPROTO_TCP, TCP_LINGER2, (

*)&

,

(

));

(res && (x_errno = errno) == EINTR);

--

->socks->sock_cnt;

snprintf(

, 20,

, hb[0], hb[1], hb[2], hb[3]);

sockaddr_in

;

memset(&

, 0,

(

));

.sin_family = AF_INET;

.sin_addr.s_addr =

;

,

(

),

, 0, NI_NAMEREQD | NI_NOFQDN);

LOG_WITH_AIERR(

,

, x_errno);

(gethostname(

,

(

)))

= inet_addr(host.c_str());

memset(&in_addr, 0,

(in_addr));

in_addr.ai_family = AF_INET;

LOG_WITH_AIERR(

,

, x_errno);

= ((

sockaddr_in*)out_addr->ai_addr)->sin_addr.s_addr;

sockaddr_in

;

new_sock = accept(sock_info.

, (

sockaddr*)&

, &

);

cmd_len -= cmd_start;

(

,

<< len_usec <<

);

(new_sock == -1) {

(x_errno != EAGAIN && x_errno != EWOULDBLOCK) {

<<

);

task->

= new_sock;

wait_msec = wait_time.

() / 1000000;

(x_errno != EINTR)

(

= 0;

< res; ++

) {

epoll_event& evt = events[

];

memset(old_socks, 0,

(old_socks));

memset(old_active, 0,

(old_active));

(active >= limit_time)

low = 0, high = cnt_old;

mid = (high + low) / 2;

(old_active[mid] > active)

(&old_socks[low + 1], &old_socks[low],

(cnt_old - low) *

(old_socks[0]));

(&old_active[low + 1], &old_active[low],

(cnt_old - low) *

(old_active[0]));

old_socks[low] = task;

old_active[low] = active;

(

= 0;

< cnt_old; ++

) {

(*it)->SetRunnable();

(x_errno == EINTR)

(x_errno == EWOULDBLOCK) {

(x_errno == EAGAIN) {

size_t(n_read);

(n_written == -1) {

(x_errno == EINTR)

(x_errno == EAGAIN || x_errno == EWOULDBLOCK) {

size_t(n_written);

(c ==

|| c ==

) {

finish_with_error;

(

!= 0) {

(to_write >

)

finish_with_error;

(n_done < to_write) {

finish_with_error;

(to_read >

)

finish_with_error;

(n_done > to_read)

finish_with_error;

finish_with_error;

unlock_and_exit;

sock_info->

= idx;

sock_info->

= port;

sock_info->

= factory;

m_TaskName =

;

(

= 0;

< cnt_listen; ++

) {

(sock_info.

!= -1)

: m_ProxySrc(

),

m_ProxyHadError(

),

m_SockHasRead(

),

m_SockCanWrite(

),

m_SockCanReadMore(

),

m_NeedToClose(

),

m_NeedToFlush(

),

m_RegReadHup(

),

m_RegError(

),

m_ErrorPrinted(

)

m_TaskName =

;

(c ==

|| c ==

|| c ==

)

(

[crlf_pos] ==

) {

= (

*)

+ copied;

(has_size == 0) {

= (

*)

+ to_copy;

to_copy + n_written;

sock = socket(AF_INET, SOCK_STREAM, 0);

close_and_error;

sockaddr_in

;

memset(&

, 0,

(

));

.sin_family = AF_INET;

.sin_addr.s_addr = host;

.sin_port = htons(port);

res = connect(sock, (

sockaddr*)&

,

(

));

x_errno = errno;

(x_errno == EINTR)

(x_errno != EINPROGRESS) {

close_and_error;

epoll_event evt;

res = epoll_ctl(

, EPOLL_CTL_ADD,

, &evt);

sockaddr_in

;

(getsockname(

, (

sockaddr*)&

, &

) == 0)

ntohs(

.sin_port);

void MarkTaskTerminated(CSrvTask *task, bool immediate)

Mutex created to have minimum possible size (its size is 4 bytes) and to sleep using kernel capabilit...

void Unlock(void)

Unlock the mutex.

void Lock(void)

Lock the mutex.

Class used in all diagnostic logging.

const CSrvDiagMsg & StartSrvLog(ESeverity sev, const char *file, int line, const char *func) const

Starts log message which will include severity, filename, line number and function name.

CSrvDiagMsg & StartRequest(void)

Starts "request-start" message.

CSrvDiagMsg & PrintParam(CTempString name, CTempString value)

Adds parameter to "request-start" or "extra" message.

void StopRequest(void)

Prints "request-stop" message.

static bool IsSeverityVisible(ESeverity sev)

Checks if given severity level is visible, i.e.

ESeverity

Severity levels for logging.

virtual ~CSrvListener(void)

Uint4 m_SeenErrors[kMaxCntListeningSocks]

Per-listening-socket numbers copied from s_ListenErrors when errors are processed.

virtual void ExecuteSlice(TSrvThreadNum thread_idx)

This is the main method to do all work this task should do.

Uint4 m_SeenEvents[kMaxCntListeningSocks]

Per-listening-socket numbers copied from s_ListenEvents when events are processed.

Factory that creates CSrvSocketTask-derived object for each connection coming to listening port which...

virtual CSrvSocketTask * CreateSocketTask(void)=0

virtual ~CSrvSocketFactory(void)

Task controlling a socket.

Uint2 m_WrPos

Position of current writing pointer in the write buffer.

Uint8 m_ConnStartJfy

Jiffy number when Connect() method was called.

bool Connect(Uint4 host, Uint2 port)

Create new socket and connect it to given IP and port.

void x_CloseSocket(bool do_abort)

Close or abort the socket – they have little difference, thus they joined in one method.

bool m_RegReadHup

Flag showing if epoll returned RDHUP on this socket.

CSrvSocketTask * m_ProxySrc

Source task for proxying.

Uint1 m_SeenWriteEvts

Number of last write event seen by Write() when it wrote to socket.

bool HasError(void)

Checks if socket has some error in it.

bool m_CRMet

Flag showing if '\r' symbol was seen at the end of last line but ' ' wasn't seen yet.

Uint8 m_ReadBytes

Total number of bytes read from socket.

int m_Fd

File descriptor for the socket.

size_t Write(const void *buf, size_t size)

Write into the socket as much as immediately possible (including writing into internal write buffers ...

Uint2 m_PeerPort

Remembered peer port.

CSrvSocketTask & WriteText(CTempString message)

Write text into socket.

CSrvSocketTask & WriteNumber(NumType num)

Write number into socket as string, i.e.

void GetPeerAddress(string &host, Uint2 &port)

Get peer IP and port for this socket.

void CloseSocket(void)

Close the socket gracefully, i.e.

Uint2 m_WrMemSize

Size of memory allocated for write buffer.

Uint8 m_ProxySize

Amount left to proxy if proxying operation is in progress.

bool m_NeedToFlush

Flag showing that task needs to flush all write buffers.

virtual void InternalRunSlice(TSrvThreadNum thr_num)

Internal function to execute time slice work.

virtual void Terminate(void)

Terminate the task.

bool m_NeedToClose

Flag showing that socket needs to be closed because of long inactivity.

char * m_RdBuf

Read buffer.

Uint4 m_PeerAddr

Remembered peer IP address.

bool m_ErrorPrinted

Flag showing if pending error in socket was printed in logs.

bool m_ProxyHadError

Flag showing that last proxying operation finished with error.

bool m_SockCanReadMore

Flag showing that socket can have more reads, i.e. there was no EOF yet.

bool m_FlushIsDone

Flag showing that write buffers were flushed.

bool m_RegError

Flag showing if there's error pending on the socket.

CSrvSocketTask * m_ProxyDst

Destination task for proxying.

bool ReadToBuf(void)

Read from socket into internal buffer.

Uint2 m_RdPos

Position of current reading in the read buffer, i.e.

void Flush(void)

Flush all data saved in internal write buffers to socket.

size_t Read(void *buf, size_t size)

Read from socket into memory.

char * m_WrBuf

Write buffer.

virtual ~CSrvSocketTask(void)

Uint2 GetLocalPort(void)

Get local port this socket was created on.

void WriteData(const void *buf, size_t size)

Write the exact amount of data into the socket.

Uint1 m_SeenReadEvts

Number of last read event seen by Read() when it read from socket.

bool IsWriteDataPending(void)

Checks if there's some data pending in write buffers and waiting to be sent to kernel.

Uint2 m_WrSize

Size of data in the write buffer waiting for writing.

Uint8 m_WrittenBytes

Total number of bytes written to socket.

Uint2 m_RdSize

Size of data available for reading in the read buffer.

bool m_SockCanWrite

Flag showing that socket is writable.

bool StartProcessing(TSrvThreadNum thread_num=0, bool boost=false)

Start processing of the socket and include it into TaskServer's central epoll.

bool ReadLine(CTempString *line)

Read from socket one line which ends with ' ', '\r ' or '\0'.

bool NeedEarlyClose(void)

Checks if socket should be closed because of internal reasons (long inactivity or "hard" shutdown as ...

void x_PrintError(void)

Prints socket's error if there's any error pending on the socket.

void StartProxyTo(CSrvSocketTask *dst_task, Uint8 proxy_size)

Start proxying of raw data from this socket to the one in dst_task.

Uint1 m_RegWriteEvts

Counter of "writable" events received from epoll.

bool m_SockHasRead

Flag showing that socket is readable.

Uint1 m_RegReadEvts

Counter of "readable" events received from epoll.

void SockOpenActive(void)

void SockClose(int status, Uint8 open_time)

void SockOpenPassive(void)

Main working entity in TaskServer.

TSrvTaskFlags m_TaskFlags

Bit-OR of flags for this task.

int m_LastActive

Time (in seconds) when the task was active last time, i.e.

CRequestContext * GetDiagCtx(void)

Get current diagnostic context for the task.

TSrvThreadNum m_LastThread

Thread number where this task was executed last time.

virtual void ExecuteSlice(TSrvThreadNum thr_num)=0

This is the main method to do all work this task should do.

void SetRunnable(bool boost=false)

Set this task "runnable", i.e.

void ReleaseDiagCtx(void)

Releases current diagnostic context of the task.

void CreateNewDiagCtx(void)

Create new diagnostic context for this task to work in.

Class incorporating convenient methods to work with struct timespec.

static int CurSecs(void)

Current time in seconds since epoch (time_t).

static CSrvTime Current(void)

Exact current time with precision up to nanoseconds.

Uint8 AsUSec(void) const

Converts object's value to microseconds since epoch.

long & NSec(void)

Read/set number of nanoseconds stored in the object.

static const string & GetHostName(void)

Returns name of server this application is executing on.

static string GetHostByIP(Uint4 ip)

Converts 4-byte encoded IP address into server name.

static bool AddListeningPort(Uint2 port, CSrvSocketFactory *factory)

Adds port for TaskServer to listen to.

static bool IsRunning(void)

Checks if TaskServer is running now, i.e.

static string IPToString(Uint4 ip)

Converts 4-byte encoded IP address into its string representation.

static bool IsInShutdown(void)

Checks if TaskServer received request to shutdown.

static Uint4 GetIPByHost(const string &host)

Converts server name (or IP address written as string) to encoded 4-byte IP address.

CTempString implements a light-weight string on top of a storage buffer whose lifetime management is ...

#define getnameinfo(a, b, c, d, e, f, g)

#define getaddrinfo(n, s, h, r)

#define ERASE_ITERATE(Type, Var, Cont)

Non-constant version with ability to erase current element, if container permits.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

void SetClientIP(const string &client)

TCount GetRequestID(void) const

Get request ID (or zero if not set).

void Critical(CExceptionArgs_Base &args)

void Error(CExceptionArgs_Base &args)

void Warning(CExceptionArgs_Base &args)

uint8_t Uint1

1-byte (8-bit) unsigned integer

int16_t Int2

2-byte (16-bit) signed integer

uint32_t Uint4

4-byte (32-bit) unsigned integer

uint16_t Uint2

2-byte (16-bit) unsigned integer

uint64_t Uint8

8-byte (64-bit) unsigned integer

virtual int GetInt(const string &section, const string &name, int default_value, TFlags flags=0, EErrAction err_action=eThrow) const

Get integer value of specified parameter name.

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

CTempString & assign(const char *src_str, size_type len)

Assign new values to the content of the a string.

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

static string UInt8ToString(Uint8 value, TNumToStringFlags flags=0, int base=10)

Convert UInt8 to string.

if(yy_accept[yy_current_state])

constexpr bool empty(list< Ts... >) noexcept

const struct ncbi::grid::netcache::search::fields::SIZE size

const GenericPointer< typename T::ValueType > T2 value

static size_t x_size(const char *dst, size_t len, const char *ptr)

Process information in the NCBI Registry, including working with configuration files.

Defines CRequestContext class for NCBI C++ diagnostic API.

static SLJIT_INLINE sljit_ins lgr(sljit_gpr dst, sljit_gpr src)

static void s_FlushData(CSrvSocketTask *task)

void CheckConnectsTimeout(SSocketsData *socks)

intr::list< CSrvSocketTask, intr::base_hook< TSrvSockListHook >, intr::constant_time_size< false > > TSockList

static void s_CloseSocket(int fd, bool do_abort)

bool ReConfig_Sockets(const CTempString &section, const CNcbiRegistry &new_reg, string &)

void ReleaseThreadSocks(SSrvThread *thr)

void RequestStopListening(void)

bool InitSocketsMan(void)

static void s_CopyData(CSrvSocketTask *task, const void *buf, Uint2 size)

static void s_ProcessListenError(Uint1 sock_idx)

static size_t s_ReadFromSocket(CSrvSocketTask *task, void *buf, size_t size)

bool StartSocketsMan(void)

static bool s_StartListening(void)

static void s_LogSocketError(CSrvDiagMsg::ESeverity severity, int fd, const char *prefix, const char *file, int line, const char *func)

static void s_CompactWrBuffer(CSrvSocketTask *task)

static const Uint1 kEpollEventsArraySize

static void s_CreateDiagRequest(CSrvSocketTask *task, Uint2 port, Uint4 phost, Uint2 pport)

void s_DeleteOldestSockets(TSockList &lst)

static void s_DoDataProxy(CSrvSocketTask *src)

#define LOG_WITH_ERRNO(sev, msg, x_errno)

static size_t s_WriteNoPending(CSrvSocketTask *task, const void *buf, size_t size)

static void s_RegisterClientEvent(CSrvSocketTask *task, Uint4 event)

void MoveAllSockets(SSocketsData *dst_socks, SSocketsData *src_socks)

void ConfigureSockets(const CNcbiRegistry *reg, CTempString section)

void AssignThreadSocks(SSrvThread *thr)

static const Uint2 kSockMinWriteSize

#define LOG_SOCK_ERROR(sev, fd, prefix)

static Uint4 s_ListenEvents[kMaxCntListeningSocks]

static Uint1 s_CntListeningSocks

static const Uint2 kSockReadBufSize

1000 below is chosen to be a little bit less than maximum packet size in Ethernet (~1500 bytes).

static const Uint2 kSockWriteBufSize

In calculations in the file it's assumed that kSockWriteBufSize is at least twice as large as kSockMi...

void CleanSocketList(SSocketsData *socks)

static Uint1 s_OldSocksDelBatch

static CSrvListener s_Listener

static SListenSockInfo s_ListenSocks[kMaxCntListeningSocks]

static Uint8 s_ConnTimeout

static Uint8 s_AcceptDelay

static Uint2 s_ReadFromBuffer(CSrvSocketTask *task, void *dest, size_t size)

static void s_LogWithErrStr(CSrvDiagMsg::ESeverity severity, const char *err_msg, int x_errno, const char *errno_str, const char *file, int line, const char *func)

static void s_LogWithErrno(CSrvDiagMsg::ESeverity severity, const char *err_msg, int x_errno, const char *file, int line, const char *func)

static void s_SaveSocket(CSrvSocketTask *task)

void WriteSetup_Sockets(CSrvSocketTask &task)

static bool s_SetSocketOptions(int sock)

static void s_SetSocketQuickAck(int sock)

static void s_CleanSockResources(CSrvSocketTask *task)

static void s_CompactBuffer(char *buf, Uint2 &size, Uint2 &pos)

static const Uint1 kMaxCntListeningSocks

16 Uint4s on x86_64 is the size of CPU's cacheline.

static CMiniMutex s_ListenSocksLock

static void s_ReadLF(CSrvSocketTask *task)

void SetAllSocksRunnable(SSocketsData *socks)

void PromoteSockAmount(SSocketsData *socks)

static bool s_CreateListeningSocket(Uint1 idx)

static void s_RegisterListenEvent(SListenSockInfo *sock_info, Uint4 event)

void FinalizeSocketsMan(void)

static void s_ProcessListenEvent(Uint1 sock_idx, TSrvThreadNum thread_num)

static Uint4 s_ListenErrors[kMaxCntListeningSocks]

static size_t s_WriteToSocket(CSrvSocketTask *task, const void *buf, size_t size)

static int s_SocketTimeout

static bool s_SetSocketNonBlock(int sock)

#define SRV_LOG(sev, msg)

Macro to be used for printing log messages.

intr::list_base_hook< intr::tag< SSrvSockList_tag > > TSrvSockListHook

T AtomicAdd(T volatile &var, T add_value)

#define ACCESS_ONCE(x)

Purpose of this macro is to force compiler to access variable exactly at the place it's written (no m...

T AtomicSub(T volatile &var, T sub_value)

constexpr Uint8 kUSecsPerSecond

constexpr Uint8 kUSecsPerMSec

constexpr Uint8 kNSecsPerMSec

CSrvSocketFactory * factory

Factory that will create CSrvSocketTask for each incoming socket.

Uint2 port

Port to listen to.

int fd

File descriptor for the listening socket.

Uint1 index

Index in the s_ListenSocks array.

Per-thread structure containing information about sockets.

Int2 sock_cnt

"Number of sockets" that this thread created/deleted.

TSockList sock_list

List of all open and not yet deleted sockets which were opened in this thread.

For TaskServer's internal use only.

Uint2 TSrvThreadNum

Type for thread number in TaskServer.

CRef< CTestThread > thr[k_NumThreadsMax]

SSrvThread * GetCurThread(void)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4