/*
* Mark a queue as closed. No further IO is permitted.
* All blocks are released.
*/
void
qclose(Queue *q)
{
Block *bfirst;
if(q == nil)
return;
/* mark it */
lock(&q->l);
q->state |= Qclosed;
q->state &= ~(Qflow|Qstarve);
strcpy(q->err, Ehungup);
bfirst = q->bfirst;
q->bfirst = 0;
q->len = 0;
q->dlen = 0;
q->noblock = 0;
unlock(&q->l);
/* free queued blocks */
freeblist(bfirst);
/* wake up readers/writers */
Wakeup(&q->rr);
Wakeup(&q->wr);
}
static void
cmdproc(void *a)
{
Conv *c;
int n;
char status[ERRMAX];
void *t;
c = a;
qlock(&c->l);
if(Debug)
print("f[0]=%q f[1]=%q\n", c->cmd->f[0], c->cmd->f[1]);
if(waserror()){
if(Debug)
print("failed: %q\n", up->env->errstr);
kstrdup(&c->error, up->env->errstr);
c->state = "Done";
qunlock(&c->l);
Wakeup(&c->startr);
pexit("cmdproc", 0);
}
t = oscmd(c->cmd->f+1, c->nice, c->dir, c->fd);
if(t == nil)
oserror();
c->child = t; /* to allow oscmdkill */
poperror();
qunlock(&c->l);
Wakeup(&c->startr);
if(Debug)
print("started\n");
while(waserror())
oscmdkill(t);
osenter();
n = oscmdwait(t, status, sizeof(status));
osleave();
if(n < 0){
oserrstr(up->genbuf, sizeof(up->genbuf));
n = snprint(status, sizeof(status), "0 0 0 0 %q", up->genbuf);
}
qlock(&c->l);
c->child = nil;
oscmdfree(t);
if(Debug){
status[n]=0;
print("done %d %d %d: %q\n", c->fd[0], c->fd[1], c->fd[2], status);
}
if(c->inuse > 0){
c->state = "Done";
if(c->waitq != nil)
qproduce(c->waitq, status, n);
}else
closeconv(c);
qunlock(&c->l);
pexit("", 0);
}
/*
* Mark a queue as closed. Wakeup any readers. Don't remove queued
* blocks.
*/
void
qhangup(Queue *q, char *msg)
{
/* mark it */
lock(&q->l);
q->state |= Qclosed;
if(msg == 0 || *msg == 0)
strcpy(q->err, Ehungup);
else
kstrcpy(q->err, msg, sizeof q->err);
unlock(&q->l);
/* wake up readers/writers */
Wakeup(&q->rr);
Wakeup(&q->wr);
}
/*
* get next block from a queue, return null if nothing there
*/
Block*
qget(Queue *q)
{
int dowakeup;
Block *b;
/* sync with qwrite */
lock(&q->l);
b = q->bfirst;
if(b == 0){
q->state |= Qstarve;
unlock(&q->l);
return 0;
}
q->bfirst = b->next;
b->next = 0;
q->len -= BALLOC(b);
q->dlen -= BLEN(b);
QDEBUG checkb(b, "qget");
/* if writer flow controlled, restart */
if((q->state & Qflow) && q->len < q->limit/2){
q->state &= ~Qflow;
dowakeup = 1;
} else
dowakeup = 0;
unlock(&q->l);
if(dowakeup)
Wakeup(&q->wr);
return b;
}
// ---------------------------------------------------------------------------
// CTurnAsyncCallback::MakeCallbackL
// ---------------------------------------------------------------------------
//
void CTurnAsyncCallback::MakeCallbackL(
TTurnPluginCallbackInfo::TFunction aFunction,
TUint aStreamId,
TInt aErrorCode,
TAny* aEventData )
{
TTurnPluginCallbackInfo* callback =
new ( ELeave ) TTurnPluginCallbackInfo( iTurnPlugin,
iObserver,
aFunction,
aStreamId,
aErrorCode,
aEventData );
CleanupStack::PushL( callback );
__ASSERT_ALWAYS( callback->Validate(), User::Leave( KErrArgument ) );
CleanupStack::Pop( callback );
// CActive::iActive won't tell whether User::RequestComplete has already
// been called, so iStatus is inspected to see whether a previous call
// to AddDeleteRequestL has already called User::RequestComplete.
if ( iStatus == KRequestPending )
{
Wakeup();
}
iPendingCallbacks.AddLast( *callback );
}
void NetClient::CloseSocket(int socket_fd)
{
//FD_CLR
lock_tcp_map_.Lock();
std::map<int, void*>::iterator it_t = tcp_socket_map_.find(socket_fd);
if (it_t != tcp_socket_map_.end())
{
tcp_socket_map_.erase(socket_fd);
}
lock_tcp_map_.UnLock();
lock_udp_map_.Lock();
std::map<int, void*>::iterator it_u = udp_socket_map_.find(socket_fd);
if (it_u != udp_socket_map_.end()) {
udp_socket_map_.erase(socket_fd);
}
lock_udp_map_.UnLock();
lock_connecting_map_.Lock();
std::map<int, void*>::iterator iItr = connecting_map_.find(socket_fd);
if( iItr != connecting_map_.end() )
{
connecting_map_.erase(socket_fd);
}
lock_connecting_map_.UnLock();
//LogDEBUG("close scoket %d", socket_fd);
close_socket(socket_fd);
Wakeup();
}
static void
telldbg(Progctl *ctl, char *msg)
{
kstrcpy(ctl->msg, msg, ERRMAX);
ctl->debugger = nil;
Wakeup(&ctl->r);
}
void
mouseproduce(Pointer m)
{
int lastb;
Ptrevent e;
lock(&ptrq.lk);
e.x = m.x;
e.y = m.y;
e.b = m.b;
e.msec = osmillisec();
lastb = mouse.b;
mouse.x = m.x;
mouse.y = m.y;
mouse.b = m.b;
mouse.msec = e.msec;
if(!ptrq.full && lastb != m.b){
ptrq.clicks[ptrq.wr] = e;
if(++ptrq.wr == Nevent)
ptrq.wr = 0;
if(ptrq.wr == ptrq.rd)
ptrq.full = 1;
}
mouse.modify = 1;
ptrq.put++;
unlock(&ptrq.lk);
Wakeup(&ptrq.r);
/* drawactive(1); */
}
int NetClient::Connect(int fd, void* context, uint32_t remote_ip, uint16_t remote_port)
{
if (fd == INVALID_SOCKET)
{
LogERR("connect is error, error code: INVALID_SOCKET");
return -1;
}
struct sockaddr_in remote;
remote.sin_family = AF_INET;
remote.sin_addr.s_addr = htonl(remote_ip);
remote.sin_port = htons(remote_port);
int ret = ::connect(fd, (struct sockaddr*)(&remote), sizeof (remote));
int nError = 0;
if (ret < 0 && !IsIgnoreSocketError(nError))
{
//LogERR("connect is error, error code: %d", nError);
return -1;
}
lock_connecting_map_.Lock();
connecting_map_[fd] = context;
lock_connecting_map_.UnLock();
Wakeup();
return 0;
}
int main()
{
Wakeup();
while (1)
{
}
}
void CLibraryTipCtrl::OnShow()
{
OnHide(); // Do the old image destroy
BeginThread( "CtrlLibraryTip" );
Wakeup();
}
void NetClient::Stop()
{
running_ = false;
Wakeup();
while( thread_.IsRunning() )
{
CBaseThread::Sleep(10);
}
}
int
qproduce(Queue *q, void *vp, int len)
{
Block *b;
int dowakeup;
uchar *p = vp;
/* sync with qread */
dowakeup = 0;
lock(&q->l);
if(q->state & Qclosed){
unlock(&q->l);
return -1;
}
/* no waiting receivers, room in buffer? */
if(q->len >= q->limit){
q->state |= Qflow;
unlock(&q->l);
return -1;
}
/* save in buffer */
b = iallocb(len);
if(b == 0){
unlock(&q->l);
print("qproduce: iallocb failed\n");
return -1;
}
memmove(b->wp, p, len);
b->wp += len;
if(q->bfirst)
q->blast->next = b;
else
q->bfirst = b;
q->blast = b;
/* b->next = 0; done by allocb() */
q->len += BALLOC(b);
q->dlen += BLEN(b);
QDEBUG checkb(b, "qproduce");
if(q->state & Qstarve){
q->state &= ~Qstarve;
dowakeup = 1;
}
if(q->len >= q->limit)
q->state |= Qflow;
unlock(&q->l);
if(dowakeup)
Wakeup(&q->rr);
return len;
}
/* is received ir-code in one of the wakeup-slots? wakeup if true */
void check_wakeups(IRMP_DATA *ir)
{
uint8_t i, idx;
uint8_t buf[SIZEOF_IR];
for (i=0; i < WAKE_SLOTS; i++) {
idx = (MACRO_DEPTH + 1) * SIZEOF_IR/2 * MACRO_SLOTS + SIZEOF_IR/2 * i;
eeprom_restore(buf, idx);
if (!memcmp(buf, ir, sizeof(buf)))
Wakeup();
}
}
void Transceiver::ListenData()
{
if (BroadcastEnable){
Wakeup();
buffer->setChannel(myChannel);
timer.setStage(LISTENDATA);
buffer->StartReceive();
} else {
StopListen();
}
}
static void
reply(Devlogfs *d)
{
d->readp = d->readbuf;
d->readcount = convS2M(&d->out, d->readp, d->readbufsize);
//print("reply is %d bytes\n", d->readcount);
if (d->readcount == 0)
panic("logfs: reply: did not fit\n");
d->reading = 1;
Wakeup(&d->readrendez);
}
static void
dbgaddrun(Prog *p)
{
Osenv *o;
p->state = Pdebug;
p->addrun = nil;
o = p->osenv;
if(o->rend != nil)
Wakeup(o->rend);
o->rend = nil;
}
int
qpass(Queue *q, Block *b)
{
int dlen, len, dowakeup;
/* sync with qread */
dowakeup = 0;
lock(&q->l);
if(q->len >= q->limit){
unlock(&q->l);
freeblist(b);
return -1;
}
if(q->state & Qclosed){
unlock(&q->l);
len = blocklen(b);
freeblist(b);
return len;
}
/* add buffer to queue */
if(q->bfirst)
q->blast->next = b;
else
q->bfirst = b;
len = BALLOC(b);
dlen = BLEN(b);
QDEBUG checkb(b, "qpass");
while(b->next){
b = b->next;
QDEBUG checkb(b, "qpass");
len += BALLOC(b);
dlen += BLEN(b);
}
q->blast = b;
q->len += len;
q->dlen += dlen;
if(q->len >= q->limit/2)
q->state |= Qflow;
if(q->state & Qstarve){
q->state &= ~Qstarve;
dowakeup = 1;
}
unlock(&q->l);
if(dowakeup)
Wakeup(&q->rr);
return len;
}
/*
* used by print() to write to a queue. Since we may be splhi or not in
* a process, don't qlock.
*/
int
qiwrite(Queue *q, void *vp, int len)
{
int n, sofar, dowakeup;
Block *b;
uchar *p = vp;
dowakeup = 0;
sofar = 0;
do {
n = len-sofar;
if(n > Maxatomic)
n = Maxatomic;
b = iallocb(n);
if (b == 0) {
print("qiwrite: iallocb failed\n");
break;
}
memmove(b->wp, p+sofar, n);
b->wp += n;
lock(&q->l);
QDEBUG checkb(b, "qiwrite");
if(q->bfirst)
q->blast->next = b;
else
q->bfirst = b;
q->blast = b;
q->len += BALLOC(b);
q->dlen += n;
if(q->state & Qstarve){
q->state &= ~Qstarve;
dowakeup = 1;
}
unlock(&q->l);
if(dowakeup){
if(q->kick)
q->kick(q->arg);
Wakeup(&q->rr);
}
sofar += n;
} while(sofar < len && (q->state & Qmsg) == 0);
return sofar;
}
void NetClient::SetSocketContext(int socket_fd, void* context, int socket_typ)
{
if (0 == socket_typ) {
lock_tcp_map_.Lock();
tcp_socket_map_[socket_fd] = context;
lock_tcp_map_.UnLock();
} else if (1 == socket_typ) {
lock_udp_map_.Lock();
udp_socket_map_[socket_fd] = context;
lock_udp_map_.UnLock();
}
Wakeup();
}
int NetClient::SendTcpData(int socket_fd, char* data, uint32_t data_len)
{
int sended_bytes = ::send(socket_fd, data, data_len, 0);
if (-1 == sended_bytes)
{
int nError = 0;
if (IsIgnoreSocketError(nError))
{
//wake up select, add tcp write event
Wakeup();
}
LogDEBUG("NetClient tcp socket(%d) send error: %d", socket_fd, nError);
return sended_bytes;
}
if (sended_bytes < data_len)
{
//wake up select, add tcp write event
Wakeup();
}
return sended_bytes;
}
int Processor::AddNewTask(Message *msg)
{
Print(NOW "Processor enqueues ioreq@%p, %d:%llu:%llu\n",
Event::Clock(), &msg->io, msg->io.cmd, msg->io.off, msg->io.count);
if (nrs->Enqueue(msg)) {
printf(NOW "Enqueue message failed.\n", now);
exit(1);
}
if (poolState <= pool_IdleState) {
Wakeup();
}
return 0;
}
/* is received ir-code in one of the lower wakeup-slots? wakeup if true */
void check_wakeups(IRMP_DATA *ir)
{
if(host_running())
return;
uint8_t i, idx;
uint8_t buf[SIZEOF_IR];
for (i=0; i < WAKE_SLOTS/2; i++) {
idx = (MACRO_DEPTH + 1) * SIZEOF_IR/2 * MACRO_SLOTS + SIZEOF_IR/2 * i;
if (!eeprom_restore(buf, idx)) {
if (!memcmp(buf, ir, sizeof(buf)))
Wakeup();
}
}
}
bool Transceiver::SendKnock(bool invalid)
{
Wakeup();
buffer->setChannel(BroadcastChannel);
IMFrame _frame;
IMFrameSetup *setup=_frame.Setup();
_frame.Reset();
_frame.Header.Function=IMF_KNOCK;
_frame.Header.Sequence=ksequence++;
_frame.Header.SourceId=myId;
PrepareSetup(*setup);
setup->address=myHop;
if (invalid){
setup->salt=0;
}
return Send(_frame);
}
void Transceiver::ListenBroadcast()
{
if (Connected()){
if (timer.Cycle()<_helloCycle)
return;
// long xKC=(timer.Cycle()-_KnockCycle);
//if (xKC< 7)
//return;
} else {
if ((timer.Cycle() & 0x4) ==0)
return;
}
DBGINFO("listenBroad ");
DBGINFO(_KnockCycle);
Wakeup();
DoListenBroadcast();
}
// ---------------------------------------------------------------------------
// CTurnAsyncCallback::ExecuteFirstCallback
// Handle one callback request and wait for the next one. If there are more
// callbacks, complete the asynchronous request so that RunL will soon be
// called again. Don't call more than one callback, since upper layer
// might've deleted STUN plugin, causing CTurnAsyncCallback to be deleted too.
// For the same reason nothing is done after executing the callback.
// ---------------------------------------------------------------------------
//
void CTurnAsyncCallback::ExecuteFirstCallback()
{
TTurnPluginCallbackInfo* callback = iPendingCallbacks.First();
if ( iPendingCallbacks.IsFirst( callback ) &&
!iPendingCallbacks.IsEmpty() )
{
iPendingCallbacks.Remove( *callback );
if ( !iPendingCallbacks.IsEmpty() )
{
Wakeup();
}
callback->Execute();
delete callback;
}
}
void OsclSocketServRequestList::Add(OsclSocketRequest *obj)
//add a socket request to the server (from the app thread)
{
//Lock when adding requests to the input queue.
Lock();
bool empty = iAddRequests.empty();
iAddRequests.push_back(obj);
//signal the server thread anytime the queue goes from empty to non-empty.
if (empty)
Wakeup();
//may need to interrupt a blocking select call
iContainer->WakeupBlockingSelect();
Unlock();
}
IUnknown* CPlugins::GetPlugin(LPCTSTR pszGroup, LPCTSTR pszType)
{
CLSID pCLSID;
if ( ! LookupCLSID( pszGroup, pszType, pCLSID ) )
return NULL; // Disabled
HRESULT hr;
for ( int i = 0 ; ; ++i )
{
{
CSingleLock oLock( &m_pSection, FALSE );
if ( ! oLock.Lock( 500 ) ) return NULL;
CComPtr< IUnknown > pPlugin;
CPluginPtr* pGITPlugin = NULL;
if ( m_pCache.Lookup( pCLSID, pGITPlugin ) )
{
if ( ! pGITPlugin )
return NULL;
if ( SUCCEEDED( hr = pGITPlugin->m_pGIT.CopyTo( &pPlugin ) ) )
return pPlugin.Detach();
TRACE( "Invalid plugin \"%s\"-\"%s\" %s\n", (LPCSTR)CT2A( pszGroup ), (LPCSTR)CT2A( pszType ), (LPCSTR)CT2A( Hashes::toGuid( pCLSID ) ) );
}
if ( i == 1 )
break;
m_inCLSID = pCLSID;
// Create new one
if ( ! BeginThread( "PluginCache" ) )
break; // Something really bad
}
Wakeup(); // Start process
WaitForSingleObject( m_pReady, INFINITE ); // Wait for result
}
return NULL;
}
/*
* flush the output queue
*/
void
qflush(Queue *q)
{
Block *bfirst;
/* mark it */
lock(&q->l);
bfirst = q->bfirst;
q->bfirst = 0;
q->len = 0;
q->dlen = 0;
unlock(&q->l);
/* free queued blocks */
freeblist(bfirst);
/* wake up readers/writers */
Wakeup(&q->wr);
}
/*
* flow control, get producer going again
* called with q locked
*/
static void
qwakeup_unlock(Queue *q)
{
int dowakeup = 0;
/* if writer flow controlled, restart */
if((q->state & Qflow) && q->len < q->limit/2){
q->state &= ~Qflow;
dowakeup = 1;
}
unlock(&q->l);
/* wakeup flow controlled writers */
if(dowakeup){
if(q->kick)
q->kick(q->arg);
Wakeup(&q->wr);
}
}
