/*
* シリアルポートからの文字列受信（サービスコール）
*/
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);
}
/** %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
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;
}
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 BOOL
serial_wri_chr(SPCB *spcb, char c)
{
BOOL buffer_full;
/*
* LF の前に CR を送信する．
*/
if (c == '\n' && (spcb->ioctl & IOCTL_CRLF) != 0) {
if (serial_wri_chr(spcb, '\r')) {
_syscall(wai_sem(spcb->spinib->snd_semid));
}
}
_syscall(loc_cpu());
if (spcb->snd_count == 0 && !(spcb->snd_stopped)
&& serial_snd_chr(spcb, c)) {
/*
* シリアルI/Oデバイスの送信レジスタに文字を入れるこ
* とに成功した場合．
*/
buffer_full = FALSE;
}
else {
/*
* 送信バッファに文字を入れる．
*/
spcb->snd_buffer[spcb->snd_write_ptr] = c;
INC_PTR(spcb->snd_write_ptr);
spcb->snd_count++;
buffer_full = (spcb->snd_count == SERIAL_BUFSZ);
}
_syscall(unl_cpu());
return(buffer_full);
}
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;
}
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;
}
bool mupnp_mutex_lock(mUpnpMutex *mutex)
{
if (!mutex)
return false;
mupnp_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
WaitForSingleObject(mutex->mutexID, INFINITE);
#elif defined(BTRON)
wai_sem(mutex->mutexID, T_FOREVER);
#elif defined(ITRON)
twai_sem(mutex->mutexID, TMO_FEVR);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_wai_sem(mutex->mutexID, 1, TMO_FEVR);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_wai_sem(mutex->mutexID, T_FOREVER);
#else
pthread_mutex_lock(&mutex->mutexID);
#endif
mupnp_log_debug_l4("Leaving...\n");
return true;
}
/*---------------------------------------------------------------------------*
* Routine: sys_arch_protect
*---------------------------------------------------------------------------*
* Description:
* This optional function does a "fast" critical region protection and
* returns the previous protection level. This function is only called
* during very short critical regions. An embedded system which supports
* ISR-based drivers might want to implement this function by disabling
* interrupts. Task-based systems might want to implement this by using
* a mutex or disabling tasking. This function should support recursive
* calls from the same task or interrupt. In other words,
* sys_arch_protect() could be called while already protected. In
* that case the return value indicates that it is already protected.
*
* sys_arch_protect() is only required if your port is supporting an
* operating system.
* Outputs:
* sys_prot_t -- Previous protection level (not used here)
*---------------------------------------------------------------------------*/
sys_prot_t sys_arch_protect(void) {
// if (osMutexWait(lwip_sys_mutex, osWaitForever) != osOK)
if (wai_sem(lwip_sys_mutex) != E_OK) {
error("sys_arch_protect error\n");
}
return (sys_prot_t) 1;
}
/*
* 標準ファイルインターフェイス関数(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;
}
BOOL cg_mutex_lock(CgMutex *mutex)
{
if (!mutex)
return FALSE;
cg_log_debug_l4("Entering...\n");
#if defined(WIN32) && !defined(ITRON)
WaitForSingleObject(mutex->mutexID, INFINITE);
#elif defined(BTRON)
wai_sem(mutex->mutexID, T_FOREVER);
#elif defined(ITRON)
twai_sem(mutex->mutexID, TMO_FEVR);
#elif defined(TENGINE) && !defined(PROCESS_BASE)
tk_wai_sem(mutex->mutexID, 1, TMO_FEVR);
#elif defined(TENGINE) && defined(PROCESS_BASE)
b_wai_sem(mutex->mutexID, T_FOREVER);
#else
pthread_mutex_lock(&mutex->mutexID);
#endif
cg_log_debug_l4("Leaving...\n");
return TRUE;
}
void
task2(intptr_t exinf)
{
ER_UINT ercd;
switch (++task2_count) {
case 1:
check_point(2);
ercd = slp_tsk();
check_ercd(ercd, E_NOSPT);
ercd = tslp_tsk(TEST_TIME_PROC);
check_ercd(ercd, E_NOSPT);
ercd = dly_tsk(TEST_TIME_PROC);
check_ercd(ercd, E_NOSPT);
ercd = wai_sem(SEM1);
check_ercd(ercd, E_NOSPT);
ercd = pol_sem(SEM1);
check_ercd(ercd, E_OK);
ercd = pol_sem(SEM1);
check_ercd(ercd, E_TMOUT);
ercd = twai_sem(SEM1, TEST_TIME_PROC);
check_ercd(ercd, E_NOSPT);
ercd = ext_tsk();
check_ercd(ercd, E_OK);
check_point(0);
case 2:
check_point(6);
ercd = rot_rdq(MID_PRIORITY);
check_ercd(ercd, E_NOSPT);
ercd = ext_tsk();
check_ercd(ercd, E_OK);
check_point(0);
case 3:
check_point(10);
ercd = rot_rdq(MID_PRIORITY);
check_ercd(ercd, E_OK);
ercd = ext_tsk();
check_ercd(ercd, E_OK);
check_point(0);
default:
check_point(0);
}
check_point(0);
}
//#NT#2009/12/11#Bowen Li -begin
//#NT#add Semaphore for IPL
ER IPL_Lock(void)
{
ER erReturn;
erReturn = wai_sem(SEMID_IPL);
if (erReturn != E_OK)
return erReturn;
return E_OK;
}
/**
KeyScan_lockTimer
Get a sem to lock the resource
@param void
@return void
*/
static ER KeyScan_lockTimer(void)
{
ER erReturn;
erReturn = wai_sem(SEMID_KNLTIMER);
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);
}
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;
}
}
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));
}
}
}
void speed_task(intptr_t exinf)
{
while(1)
{
wai_sem(SPEED_SEM);
//输出ＰＷＭ
motor_output(MOTOR0, 15);
syslog(LOG_NOTICE, "speed_task run!");
}
}
void sensors_task(intptr_t exinf)
{
while(1)
{
wai_sem(SENSORS_SEM);
//更新传感器信息
getLaserInfo();
syslog(LOG_NOTICE, "sensors_task run!");
//释放信号量
sig_sem(FOLLOW_SEM);
}
}
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;
}
/*---------------------------------------------------------------------------*
* Routine: sys_arch_sem_wait
*---------------------------------------------------------------------------*
* Description:
* Blocks the thread while waiting for the semaphore to be
* signaled. If the "timeout" argument is non-zero, the thread should
* only be blocked for the specified time (measured in
* milliseconds).
*
* If the timeout argument is non-zero, the return value is the number of
* milliseconds spent waiting for the semaphore to be signaled. If the
* semaphore wasn't signaled within the specified time, the return value is
* SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
* (i.e., it was already signaled), the function may return zero.
*
* Notice that lwIP implements a function with a similar name,
* sys_sem_wait(), that uses the sys_arch_sem_wait() function.
* Inputs:
* sys_sem_t sem -- Semaphore to wait on
* u32_t timeout -- Number of milliseconds until timeout
* Outputs:
* u32_t -- Time elapsed or SYS_ARCH_TIMEOUT.
*---------------------------------------------------------------------------*/
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) {
u32_t start = us_ticker_read();
if (timeout != 0) {
if (twai_sem(sem->id, timeout) == E_TMOUT) {
// if (osSemaphoreWait(sem->id, (timeout != 0)?(timeout):(osWaitForever)) < 1)
return SYS_ARCH_TIMEOUT;
}
} else {
wai_sem(sem->id);
}
return (us_ticker_read() - start) / 1000;
}
ER load_application(const void *mod_data, SIZE mod_data_sz) {
ER ercd;
// ev3_led_set_color(LED_GREEN);
// chg_status(STATUS_RUNNING);
#if 0
// Wait for pressing center button
SYSTIM time = 0;
uint32_t ledcolor = 0;
syslog(LOG_NOTICE, "Press center button to run the application.");
while(!global_brick_info.button_pressed[BRICK_BUTTON_ENTER]) {
SYSTIM newtime;
get_tim(&newtime);
if (newtime - time > 500) { // Blink LED
brick_misc_command(MISCCMD_SET_LED, ledcolor);
ledcolor ^= TA_LED_RED | TA_LED_GREEN;
time = newtime;
}
}
while(global_brick_info.button_pressed[BRICK_BUTTON_ENTER]) {
SYSTIM newtime;
get_tim(&newtime);
if (newtime - time > 500) { // Blink LED
brick_misc_command(MISCCMD_SET_LED, ledcolor);
ledcolor ^= TA_LED_RED | TA_LED_GREEN;
time = newtime;
}
}
#endif
brick_misc_command(MISCCMD_SET_LED, TA_LED_GREEN);
platform_soft_reset();
ercd = dmloader_ins_ldm(mod_data, mod_data_sz, 1);
if (ercd != E_OK) {
syslog(LOG_ERROR, "Failed to load application, ercd: %d", ercd);
} else {
app_loaded = true;
SVC_PERROR(sta_alm(APP_TER_BTN_ALM, 0));
SVC_PERROR(wai_sem(APP_TER_SEM));
syslog(LOG_NOTICE, "Terminate application.");
SVC_PERROR(dmloader_rmv_ldm(1));
brick_misc_command(MISCCMD_SET_LED, TA_LED_GREEN);
}
// chg_status(STATUS_IDLE);
platform_soft_reset();
tslp_tsk(500);
return ercd;
}
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;
}
static inline void _toppers_cxxrt_recursive_semaphore_lock(ID semid)
{
if (iniflg && !sns_dsp())
{
ID tskid;
tskid = _get_tid();
if (cxxrt_holder != tskid)
{
wai_sem(semid);
cxxrt_holder = tskid;
}
++cxxrt_counter;
}
}
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;
}
static int __ui_wai_sem(struct pt_regs *regs)
{
ID semid = __xn_reg_arg1(regs);
ER err;
err = wai_sem(semid);
if (err == E_RLWAI) {
uitask_t *task = ui_current_task();
if (!xnthread_test_info(&task->threadbase, uITRON_TASK_RLWAIT))
err = -EINTR;
}
return err;
}
/*
* シリアルポートへの1文字送信
*/
static ER_BOOL
serial_wri_chr(SPCB *p_spcb, char c)
{
bool_t buffer_full;
ER ercd, rercd;
/*
* LFの前にCRを送信する．
*/
if (c == '\n' && (p_spcb->ioctl & IOCTL_CRLF) != 0U) {
/*
* 以下のコードは再帰呼出しになっているが，引数cが'\n'の場合に
* 引数cを'\r'として呼び出すことから，この再帰呼出しは2回目の
* 呼び出しで必ず止まる．
*/
SVC(rercd = serial_wri_chr(p_spcb, '\r'), rercd);
if ((bool_t) rercd) {
SVC(rercd = wai_sem(p_spcb->p_spinib->snd_semid),
gen_ercd_wait(rercd, p_spcb));
}
}
SVC(loc_cpu(), gen_ercd_sys(p_spcb));
if (p_spcb->snd_count == 0U && !(p_spcb->snd_stopped)
&& serial_snd_chr(p_spcb, c)) {
/*
* シリアルI/Oデバイスの送信レジスタに文字を入れることに成功し
* た場合．
*/
buffer_full = false;
}
else {
/*
* 送信バッファに文字を入れる．
*/
p_spcb->p_spinib->snd_buffer[p_spcb->snd_write_ptr] = c;
INC_PTR(p_spcb->snd_write_ptr, p_spcb->p_spinib->snd_bufsz);
p_spcb->snd_count++;
buffer_full = (p_spcb->snd_count == p_spcb->p_spinib->snd_bufsz);
}
SVC(unl_cpu(), gen_ercd_sys(p_spcb));
ercd = (ER_BOOL) buffer_full;
error_exit:
return(ercd);
}
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;
}
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));
}
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;
}
