/* * シリアルポートからの文字列受信(サービスコール) */ 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); //输出PWM 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; }