ER
udp_alloc_auto_port (T_UDP_CEP *cep)
{
int_t ix;
uint16_t portno, portno_start;
portno_start = udp_port_auto;
do {
portno = udp_port_auto ++;
if (udp_port_auto > UDP_PORT_LAST_AUTO)
udp_port_auto = UDP_PORT_FIRST_AUTO;
syscall(wai_sem(SEM_UDP_CEP));
for (ix = tmax_udp_ccepid; ix -- > 0; ) {
if (VALID_UDP_CEP(&udp_cep[ix]) && udp_cep[ix].myaddr.portno == portno) {
portno = UDP_PORTANY;
break;
}
}
if (portno != UDP_PORTANY) {
cep->myaddr.portno = portno;
syscall(sig_sem(SEM_UDP_CEP));
return E_OK;
}
syscall(sig_sem(SEM_UDP_CEP));
} while (portno_start != udp_port_auto);
return E_NOID;
}
/*
* 標準ファイルインターフェイス関数(open)
*/
int open(const char *pathname, int flags)
{
StorageDevice_t *psdev;
StorageDeviceFileFunc_t *pff;
int devno, id, no;
if((devno = SDMGetDeviceNo(&pathname)) < 0)
return -1;
if((psdev = SDMGetStorageDevice(devno)) == 0)
return -1;
pff = psdev->pdevff;
if(pff != 0 && pff->_sdevff_open == 0)
return -1;
wai_sem(SEM_STDFILE);
for(no = 0 ; no < NUM_FILEIDX ; no++){
if(stdfile[no].sdmfd == -1)
break;
}
if(no >= NUM_FILEIDX){
sig_sem(SEM_STDFILE);
return -1;
}
id = pff->_sdevff_open(pathname, flags);
if(id < 0){
sig_sem(SEM_STDFILE);
return id;
}
stdfile[no].sdmfd = id;
stdfile[no].sdmdev = psdev;
sig_sem(SEM_STDFILE);
return no+1;
}
/*
* シリアルポートからの文字列受信（サービスコール）
*/
ER_UINT
serial_rea_dat(ID portid, char *buf, uint_t len)
{
SPCB *p_spcb;
bool_t buffer_empty;
uint_t reacnt = 0U;
char c = '\0'; /* コンパイラの警告を抑止するために初期化する */
ER ercd, rercd;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!(1 <= portid && portid <= TNUM_PORT)) {
return(E_ID); /* ポート番号のチェック */
}
p_spcb = get_spcb(portid);
if (!(p_spcb->openflag)) { /* オープン済みかのチェック */
return(E_OBJ);
}
if (p_spcb->errorflag) { /* エラー状態かのチェック */
return(E_SYS);
}
buffer_empty = true; /* ループの1回めはwai_semする */
while (reacnt < len) {
if (buffer_empty) {
SVC(rercd = wai_sem(p_spcb->p_spinib->rcv_semid),
gen_ercd_wait(rercd, p_spcb));
}
SVC(rercd = serial_rea_chr(p_spcb, &c), rercd);
*buf++ = c;
reacnt++;
buffer_empty = (bool_t) rercd;
/*
* エコーバック処理．
*/
if ((p_spcb->ioctl & IOCTL_ECHO) != 0U) {
SVC(rercd = wai_sem(p_spcb->p_spinib->snd_semid),
gen_ercd_wait(rercd, p_spcb));
SVC(rercd = serial_wri_chr(p_spcb, c), rercd);
if (!((bool_t) rercd)) {
SVC(sig_sem(p_spcb->p_spinib->snd_semid),
gen_ercd_sys(p_spcb));
}
}
}
if (!buffer_empty) {
SVC(sig_sem(p_spcb->p_spinib->rcv_semid), gen_ercd_sys(p_spcb));
}
ercd = E_OK;
error_exit:
return(reacnt > 0U ? (ER_UINT) reacnt : ercd);
}
void
tcp_alloc_auto_port (T_TCP_CEP *cep)
{
int_t ix;
uint16_t portno;
while (true) {
portno = tcp_port_auto ++;
if (tcp_port_auto > TCP_PORT_LAST_AUTO)
tcp_port_auto = TCP_PORT_FIRST_AUTO;
#ifdef TCP_CFG_PASSIVE_OPEN
for (ix = tmax_tcp_repid; ix -- > 0; ) {
#ifdef TCP_CFG_EXTENTIONS
if (VALID_TCP_REP(&tcp_rep[ix]) && tcp_rep[ix].myaddr.portno == portno) {
portno = TCP_PORTANY;
break;
}
#else /* of #ifdef TCP_CFG_EXTENTIONS */
if (tcp_rep[ix].myaddr.portno == portno) {
portno = TCP_PORTANY;
break;
}
#endif /* of #ifdef TCP_CFG_EXTENTIONS */
}
#endif /* of #ifdef TCP_CFG_PASSIVE_OPEN */
if (portno != TCP_PORTANY) {
syscall(wai_sem(SEM_TCP_CEP));
for (ix = tmax_tcp_cepid; ix -- > 0; ) {
if (VALID_TCP_CEP(&tcp_cep[ix]) && tcp_cep[ix].myaddr.portno == portno) {
portno = TCP_PORTANY;
break;
}
}
if (portno != TCP_PORTANY) {
cep->myaddr.portno = portno;
syscall(sig_sem(SEM_TCP_CEP));
return;
}
syscall(sig_sem(SEM_TCP_CEP));
}
}
}
bool_t
arp_resolve (T_IF_ADDR *ifaddr, T_NET_BUF *output, T_IN4_ADDR gw)
{
T_ARP_ENTRY *ent;
T_ETHER_HDR *eth;
T_IFNET *ifp = IF_GET_IFNET();
eth = GET_ETHER_HDR(output);
/*
* 次の場合は、イーサネットのブロードキャストアドレスを返す。
*
* ・全ビットが 1
* ・ホスト部の全ビットが 1 で、ネットワーク部がローカルアドレス
*/
if (gw == IPV4_ADDR_BROADCAST ||
gw == ((ifp->in_ifaddr.addr & ifp->in_ifaddr.mask) | ~ifp->in_ifaddr.mask)) {
memcpy(eth->dhost, ether_broad_cast_addr, ETHER_ADDR_LEN);
return true;
}
/* 送信先 GW の IP アドレスが ARP キャッシュにあるか調べる。*/
syscall(wai_sem(SEM_ARP_CACHE_LOCK));
ent = arp_lookup(gw, true);
if (ent->expire) {
memcpy(eth->dhost, ent->mac_addr, ETHER_ADDR_LEN);
syscall(sig_sem(SEM_ARP_CACHE_LOCK));
return true;
}
else {
/* 送信がペンデングされているフレームがあれば捨てる。*/
if (ent->hold) {
NET_COUNT_IP4(net_count_ip4[NC_IP4_OUT_ERR_PACKETS], 1);
syscall(rel_net_buf(ent->hold));
}
/*
* 送信をペンディングする。
* IF でネットワークバッファを開放しないフラグが設定されているときは、
* 送信をペンディングしない。
*/
if ((output->flags & NB_FLG_NOREL_IFOUT) == 0)
ent->hold = output;
else {
output->flags &= (uint8_t)~NB_FLG_NOREL_IFOUT;
ent->hold = NULL;
}
syscall(sig_sem(SEM_ARP_CACHE_LOCK));
/* アドレス解決要求を送信する。*/
arp_request(ifaddr, gw);
return false;
}
}
/** %jp{サンプルタスク} */
void Sample_Task(VP_INT exinf)
{
int num;
num = (int)exinf;
/* %jp{いわゆる哲学者の食事の問題} */
for ( ; ; )
{
/* %jp{適当な時間考える} */
print_state(num, "thinking");
rand_wait();
/* %jp{左右のフォークを取るまでループ} */
for ( ; ; )
{
/* %jp{左から順に取る} */
wai_sem(LEFT(num));
if ( pol_sem(RIGHT(num)) == E_OK )
{
break; /* %jp{両方取れた} */
}
sig_sem(LEFT(num)); /* %jp{取れなければ離す} */
/* %jp{適当な時間待つ} */
print_state(num, "hungry");
rand_wait();
/* %jp{右から順に取る} */
wai_sem(RIGHT(num));
if ( pol_sem(LEFT(num)) == E_OK )
{
break; /* %jp{両方取れた} */
}
sig_sem(RIGHT(num)); /* %jp{取れなければ離す} */
/* %jp{適当な時間待つ} */
print_state(num, "hungry");
rand_wait();
}
/* %jp{適当な時間、食べる} */
print_state(num, "eating");
rand_wait();
/* %jp{フォークを置く} */
sig_sem(LEFT(num));
sig_sem(RIGHT(num));
}
}
ER
tcp_alloc_port (T_TCP_CEP *cep, uint16_t portno)
{
int_t ix;
syscall(wai_sem(SEM_TCP_CEP));
for (ix = tmax_tcp_cepid; ix -- > 0; )
if (VALID_TCP_CEP(cep) && tcp_cep[ix].myaddr.portno == portno) {
syscall(sig_sem(SEM_TCP_CEP));
return E_PAR;
}
cep->myaddr.portno = portno;
syscall(sig_sem(SEM_TCP_CEP));
return E_OK;
}
ER
udp_alloc_port (T_UDP_CEP *cep, uint16_t portno)
{
int_t ix;
syscall(wai_sem(SEM_UDP_CEP));
for (ix = tmax_udp_ccepid; ix -- > 0; )
if (VALID_UDP_CEP(&udp_cep[ix]) && udp_cep[ix].myaddr.portno == portno) {
syscall(sig_sem(SEM_UDP_CEP));
return E_PAR;
}
cep->myaddr.portno = portno;
syscall(sig_sem(SEM_UDP_CEP));
return E_OK;
}
ER
ppp_output (T_NET_BUF *output, TMO tmout)
{
ER error = E_OK;
#ifdef PPP_CFG_MODEM
#if 0 /* 保留 */
/* モデムの接続完了まで待つ。*/
if ((error = wait_modem()) != E_OK)
goto buf_ret;
#endif
#endif /* of #ifdef PPP_CFG_MODEM */
/* IPCP の接続完了まで待つ。*/
if ((error = wait_ipcp()) != E_OK)
goto buf_ret;
#ifdef PPP_IDLE_TIMEOUT
wai_sem(SEM_IDLE_TIMEOUT);
if (idle) {
untimeout((FP)idle_timeout, NULL);
idle = false;
}
sig_sem(SEM_IDLE_TIMEOUT);
#endif /* of #ifdef PPP_IDLE_TIMEOUT */
/* PPP 出力キューに投入する。*/
if ((error = tsnd_dtq(DTQ_PPP_OUTPUT, output, tmout)) != E_OK)
goto buf_ret;
#ifdef PPP_IDLE_TIMEOUT
wai_sem(SEM_IDLE_TIMEOUT);
if (!idle && ppp_phase == PPP_PHASE_NETWORK) {
timeout((FP)idle_timeout, NULL, PPP_IDLE_TIMEOUT);
idle = true;
}
sig_sem(SEM_IDLE_TIMEOUT);
#endif /* of #ifdef PPP_IDLE_TIMEOUT */
return error;
buf_ret:
syscall(rel_net_buf(output));
NET_COUNT_PPP(net_count_ppp.out_err_packets, 1);
return error;
}
void UI_EndScreen(UIScreen ScreenObj)
{
GxGfx_SetOrigin(_sys_pDC[0], _sys_Orig[0].x, _sys_Orig[0].y);
if (FWRotate_GetStatus() == TRUE)
{
GxGfx_CopyEx(pShowDC, pPaintDC, ROP_ROTATE|SRC_RCCW_90, 0); //copy paint to show
}
GxDisplay_EndDraw(LAYER_OSD1, _sys_pDC[0]);
#if 0 //if not init VDO ,should not call end draw //Janice 20090203
GxGfx_SetOrigin(_sys_pDC[1], _sys_Orig[1].x, _sys_Orig[1].y);
GxDisplay_EndDraw(LAYER_VDO1, _sys_pDC[1]);
#endif
if(bChagePalette)
{
GxDisplay_SetPalette(g_LayerID,g_uiStartID,g_uiCount,g_pTable);
bChagePalette = FALSE;
}
if(bNotFlip)
{
bNotFlip = FALSE;
}
else
{ //2009/03/11 Janice ::update Gx lib and set TURE for fix screen blink
if(ide_get_en())
GxDisplay_Flip(TRUE); // bFlipWaitFrameEnd
}
sig_sem(SEMID_UIGRAPHIC);
}
ER_UINT
serial_rea_dat(ID portid, char *buf, UINT len)
{
SPCB *spcb;
BOOL buffer_empty;
UINT i;
if (sns_dpn()) { /* コンテキストのチェック */
return(E_CTX);
}
if (!(1 <= portid && portid <= TNUM_PORT)) {
return(E_ID); /* ポート番号のチェック */
}
spcb = get_spcb(portid);
if (!(spcb->openflag)) { /* オープン済みかのチェック */
return(E_OBJ);
}
buffer_empty = TRUE; /* ループの1回めは wai_sem する */
for (i = 0; i < len; i++) {
if (buffer_empty) {
_syscall(wai_sem(spcb->spinib->rcv_semid));
}
buffer_empty = serial_rea_chr(spcb, buf++);
}
if (!buffer_empty) {
_syscall(sig_sem(spcb->spinib->rcv_semid));
}
return((ER_UINT) len);
}
static void kernel_evt_hdr(const T_EVTINF *evtinf) {
static SYSTIM back_press_time;
switch(evtinf->evtcd) {
case EVTCD_BUTTON_CLICKED:
break;
case EVTCD_BUTTON_PRESSED:
assert(evtinf->arg[0] >= 0 || evtinf->arg[0] < TNUM_BUTTON);
if(evtinf->arg[0] == BACK_BUTTON && status == STATUS_RUNNING)
get_tim(&back_press_time);
syslog(LOG_NOTICE, "HERE EVTCD_BUTTON_PRESSED");
break;
case EVTCD_BUTTON_RELEASED:
assert(evtinf->arg[0] >= 0 || evtinf->arg[0] < TNUM_BUTTON);
if(evtinf->arg[0] == BACK_BUTTON && status == STATUS_RUNNING) {
SYSTIM now;
get_tim(&now);
if(now - back_press_time >= 500) {
syslog(LOG_NOTICE, "HERE sig_sem(APP_TER_SEM)");
sig_sem(APP_TER_SEM);
}
}
break;
default:
syslog(LOG_NOTICE, "Unhandled evtinf->evtcd %d", evtinf->evtcd);
}
}
/*
* シリアルポートからの送信可能コールバック
*/
void
sio_irdy_snd(intptr_t exinf)
{
SPCB *p_spcb;
p_spcb = (SPCB *) exinf;
if (p_spcb->rcv_fc_chr != '\0') {
/*
* START/STOPを送信する．
*/
(void) sio_snd_chr(p_spcb->p_siopcb, p_spcb->rcv_fc_chr);
p_spcb->rcv_fc_chr = '\0';
}
else if (!(p_spcb->snd_stopped) && p_spcb->snd_count > 0U) {
/*
* 送信バッファ中から文字を取り出して送信する．
*/
(void) sio_snd_chr(p_spcb->p_siopcb,
p_spcb->p_spinib->snd_buffer[p_spcb->snd_read_ptr]);
INC_PTR(p_spcb->snd_read_ptr, p_spcb->p_spinib->snd_bufsz);
if (p_spcb->snd_count == p_spcb->p_spinib->snd_bufsz) {
if (sig_sem(p_spcb->p_spinib->snd_semid) < 0) {
p_spcb->errorflag = true;
}
}
p_spcb->snd_count--;
}
else {
/*
* 送信すべき文字がない場合は，送信可能コールバックを禁止する．
*/
sio_dis_cbr(p_spcb->p_siopcb, SIO_RDY_SND);
}
}
char *
mac2str (char *buf, uint8_t *macaddr)
{
static char addr_sbuf[NUM_MACADDR_STR_BUFF][sizeof("00:00:00:00:00:00")];
static int_t bix = NUM_MACADDR_STR_BUFF;
char *start;
if (buf == NULL) {
syscall(wai_sem(SEM_MAC2STR_BUFF_LOCK));
buf = addr_sbuf[-- bix];
if (bix <= 0)
bix = NUM_MACADDR_STR_BUFF;
syscall(sig_sem(SEM_MAC2STR_BUFF_LOCK));
}
start = buf;
buf += convert_hexdigit(buf, (uint_t)(*macaddr ++), 16, 2, '0');
*(buf ++) = ':';
buf += convert_hexdigit(buf, (uint_t)(*macaddr ++), 16, 2, '0');
*(buf ++) = ':';
buf += convert_hexdigit(buf, (uint_t)(*macaddr ++), 16, 2, '0');
*(buf ++) = ':';
buf += convert_hexdigit(buf, (uint_t)(*macaddr ++), 16, 2, '0');
*(buf ++) = ':';
buf += convert_hexdigit(buf, (uint_t)(*macaddr ++), 16, 2, '0');
*(buf ++) = ':';
buf += convert_hexdigit(buf, (uint_t)(*macaddr ++), 16, 2, '0');
*buf = '\0';
return start;
}
/* システム用ミューテックスロック解除*/
void SysMtx_Unlock(SYSMTX_HANDLE hMtx)
{
#ifdef _HOS_SYSPAI_USEMTX
unl_mtx((ID)hMtx);
#else
sig_sem((ID)hMtx);
#endif
}
ER IPL_Unlock(void)
{
ER erReturn;
erReturn = sig_sem(SEMID_IPL);
if (erReturn != E_OK)
return erReturn;
return E_OK;
}
/** %jp{適当な時間待つ} */
void rand_wait(void)
{
int r;
wai_sem(SEMID_RAND);
r = rand();
sig_sem(SEMID_RAND);
dly_tsk((r % 1000) + 10);
}
static inline void _toppers_cxxrt_recursive_semaphore_unlock(ID semid)
{
if (iniflg && !sns_dsp())
{
if (--cxxrt_counter == 0)
{
cxxrt_holder = 0;
sig_sem(semid);
}
}
}
void
put_char (ID cepid, char ch)
{
if (connected) {
if (ch == '\n' && (net_ioctl & IOCTL_CRLF) != 0)
put_char(cepid, '\r');
syscall(wai_sem(SEM_NET_SEND));
if (snd_off >= snd_len) {
if (tcp_snd_buf(cepid, snd_off) != E_OK) {
syscall(sig_sem(SEM_NET_SEND));
return;
}
snd_off = 0;
if ((snd_len = tcp_get_buf(cepid, (VP*)&snd_buff, TMO_FEVR)) <= 0) {
syscall(sig_sem(SEM_NET_SEND));
return;
}
}
snd_buff[snd_off ++] = ch;
syscall(sig_sem(SEM_NET_SEND));
}
}
void
flush_snd_buff (ID cepid)
{
if (connected) {
syscall(wai_sem(SEM_NET_SEND));
if (snd_off > 0) {
tcp_snd_buf(cepid, snd_off);
snd_len = snd_off = 0;
}
syscall(sig_sem(SEM_NET_SEND));
}
return;
}
void sensors_task(intptr_t exinf)
{
while(1)
{
wai_sem(SENSORS_SEM);
//更新传感器信息
getLaserInfo();
syslog(LOG_NOTICE, "sensors_task run!");
//释放信号量
sig_sem(FOLLOW_SEM);
}
}
bool mupnp_mutex_unlock(mUpnpMutex *mutex)
{
if (!mutex)
return false;
mupnp_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
ReleaseMutex(mutex->mutexID);
#elif defined(BTRON)
sig_sem(mutex->mutexID);
#elif defined(ITRON)
sig_sem(mutex->mutexID);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_sig_sem(mutex->mutexID, 1);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_sig_sem(mutex->mutexID);
#else
pthread_mutex_unlock(&mutex->mutexID);
#endif
return true;
mupnp_log_debug_l4("Leaving...\n");
}
BOOL cg_mutex_unlock(CgMutex *mutex)
{
if (!mutex)
return FALSE;
cg_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
ReleaseMutex(mutex->mutexID);
#elif defined(BTRON)
sig_sem(mutex->mutexID);
#elif defined(ITRON)
sig_sem(mutex->mutexID);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_sig_sem(mutex->mutexID, 1);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_sig_sem(mutex->mutexID);
#else
pthread_mutex_unlock(&mutex->mutexID);
#endif
return TRUE;
cg_log_debug_l4("Leaving...\n");
}
/**
* @fn static int exec_by_interrupt(const SpiDeviceConfigurator_t* config, const void* pTx, int nTx, void* pRx, int nRx )
* @brief SPI execute using interrupt
* @param config a SPI Configuration
* @param pTx Tx Buffer pointer
* @param nTx number of the send units
* @param pRx Rx Buffer pointer
* @param nRx number of the receive units
*/
static int exec_by_interrupt(const SpiDeviceConfigurator_t* config, const void* pTx, int nTx, void* pRx, int nRx )
{
int ret = (nTx > nRx)? nTx : nRx;
spi_start(config,pTx,nTx,pRx,nRx);
ena_int(INHNO_SPI0);
if( twai_sem( SPI_COMPLETE_SIG , SPI_TIMEOUT_PER_BYTE * ret) != E_OK )
{
sig_sem( SPI_COMPLETE_SIG );
ret = 0;
}
return ret;
}
char *
ipv62str (char *buf, const T_IN6_ADDR *p_ip6addr)
{
static char addr_sbuf[NUM_IPV6ADDR_STR_BUFF][sizeof("0123:4567:89ab:cdef:0123:4567:89ab:cdef")];
static int_t bix = NUM_IPV6ADDR_STR_BUFF;
bool_t omit = false, zero = false;
char *start;
int_t ix;
if (buf == NULL) {
syscall(wai_sem(SEM_IP2STR_BUFF_LOCK));
buf = addr_sbuf[-- bix];
if (bix <= 0)
bix = NUM_IPV6ADDR_STR_BUFF;
syscall(sig_sem(SEM_IP2STR_BUFF_LOCK));
}
start = buf;
if (p_ip6addr == NULL) {
*buf ++ = ':';
*buf ++ = ':';
}
else {
for (ix = 0; ix < sizeof(T_IN6_ADDR) / 2; ix ++) {
if (omit) {
buf += convert_hexdigit(buf, ntohs(p_ip6addr->s6_addr16[ix]), 16, 0, ' ');
if (ix < 7)
*buf ++ = ':';
}
else if (ix > 0 && ix < 7 && p_ip6addr->s6_addr16[ix] == 0)
zero = true;
else {
if (zero) {
omit = true;
*buf ++ = ':';
}
buf += convert_hexdigit(buf, ntohs(p_ip6addr->s6_addr16[ix]), 16, 0, ' ');
if (ix < 7)
*buf ++ = ':';
}
}
}
*buf = '\0';
return start;
}
/*---------------------------------------------------------------------------*
* Routine: sys_sem_signal
*---------------------------------------------------------------------------*
* Description:
* Signals (releases) a semaphore
* Inputs:
* sys_sem_t sem -- Semaphore to signal
*---------------------------------------------------------------------------*/
void sys_sem_signal(sys_sem_t *data) {
ER ercd;
if (sns_ctx()) {
ercd = isig_sem(data->id);
} else {
ercd = sig_sem(data->id);
}
// if (osSemaphoreRelease(data->id) != osOK)
if (ercd != E_OK) {
// syslog(LOG_NOTICE, "Error with ercd=%d in sys_sem_signal.", ercd);
// mbed_die(); /* Can be called by ISR do not use printf */
return;
}
// syslog(LOG_NOTICE, " Semaphore (ID=%d) was released.", data->id);
}
void
ip_frag_timer (void)
{
T_NET_BUF *frag;
int_t ix;
syscall(wai_sem(SEM_IP4_FRAG_QUEUE));
for (ix = NUM_IP4_FRAG_QUEUE; ix -- > 0; ) {
frag = ip_frag_queue[ix];
if (frag != NULL && GET_QIP4_HDR(frag)->ttl > 0 &&
-- GET_QIP4_HDR(frag)->ttl == 0) {
NET_COUNT_IP4(net_count_ip4[NC_IP4_FRAG_IN_TMOUT], 1);
NET_COUNT_IP4(net_count_ip4[NC_IP4_FRAG_IN_DROP], 1);
ip_freef(ix);
}
}
syscall(sig_sem(SEM_IP4_FRAG_QUEUE));
}
/*
* 標準ファイルインターフェイス関数(close)
*/
int close(int fd)
{
struct StdFileIndex *ps;
StorageDevice_t *psdev;
int result;
if((ps = fdcheck(fd)) == 0)
return -1;
wai_sem(SEM_STDFILE);
psdev = ps->sdmdev;
if(psdev->pdevff != 0 && psdev->pdevff->_sdevff_close != 0)
result = psdev->pdevff->_sdevff_close(ps->sdmfd);
else
result = -1;
ps->sdmfd = -1;
sig_sem(SEM_STDFILE);
return result;
}
ER
disconnecting (void)
{
ER error = E_OK;
if (connected) {
syscall(wai_sem(SEM_NET_SEND));
if (snd_off > 0)
tcp_snd_buf(TCP_CEPID, snd_off);
tcp_sht_cep(TCP_CEPID);
tcp_cls_cep(TCP_CEPID, TMO_FEVR);
connected = FALSE;
syscall(sig_sem(SEM_NET_SEND));
IP2STR(addr, &dst.ipaddr);
syslog(LOG_NOTICE, "disconnected: %s.%d", addr, dst.portno);
}
return error;
}
static void Lens_Module_SetState(LENS_STATE state)
{
if (Lens_semid != LENS_SEMID_INIT_VALUE)
{
wai_sem(Lens_semid);
}
else
{
DBG_ERR("%s Lens_semid init error\r\n", __func__);
}
uiLensModuleState = state;
if (Lens_semid != LENS_SEMID_INIT_VALUE)
{
sig_sem(Lens_semid);
}
}