static ssize_t socket_write(struct idesc *desc, const void *buff,
size_t size) {
int ret;
struct msghdr msg;
struct iovec iov;
struct sock *sk = (struct sock *)desc;
assert(desc);
assert(desc->idesc_ops == &task_idx_ops_socket);
if (sk->shutdown_flag & (SHUT_WR + 1))
return -EPIPE;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = 0;
iov.iov_base = (void *)buff;
iov.iov_len = size;
ret = ksendmsg(sk, &msg, desc->idesc_flags);
if (ret != 0) {
return ret;
}
return iov.iov_len;
}
/* open? write */
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags) {
int ret;
struct msghdr msg_;
struct sock *sk;
socket_idesc_check(sockfd, sk);
if (sk->shutdown_flag & (SHUT_WR + 1))
return SET_ERRNO(EPIPE);
/* TODO remove this */
if (flags != 0) {
LOG_ERROR("sendmsg", "flags are not supported");
return SET_ERRNO(EOPNOTSUPP);
}
if ((msg == NULL) || (msg->msg_iov == NULL)
|| (msg->msg_iovlen == 0)) {
return SET_ERRNO(EINVAL);
}
memcpy(&msg_, msg, sizeof (msg_));
msg_.msg_flags = flags;
ret = ksendmsg(sk, &msg_, sk->idesc.idesc_flags);
if (ret < 0) {
return SET_ERRNO(-ret);
}
return ret;
}
void
systime_tick(void){
/* keep track of real time */
systime += PROC_TIME;
#ifdef USE_PROC
struct Proc *p;
wakeup( &systime );
for(p=(struct Proc*)proclist; p; p=p->next){
/* check timeouts */
if( p->state & PRS_BLOCKED ){
if( p->timeout && p->timeout <= systime ){
p->timeout = 0;
sigunblock(p);
if( p->wchan != WCHAN_NEVER )
ksendmsg(p, MSG_TIMEOUT);
}
}
/* handle alarm clocks */
if( p->alarm && p->alarm <= get_time() ){
p->alarm = 0;
if( p->state & PRS_BLOCKED )
sigunblock(p);
ksendmsg(p, MSG_ALARM);
}
}
if( currproc && (--timeremain <= 0) ){
sched_yield();
}
#endif
}
static void
serial_irq(int unit){
USART_TypeDef *addr = com[unit].addr;
int sr = addr->ISR;
//kprintf("s %d %x\n", unit, sr);
if( sr & SR_TXE ){
/* transmitter empty */
//blink(1);
addr->CR1 &= ~ 0xC0; // disable TXE irq
wakeup( addr );
}
if( sr & SR_RXNE ){
/* got a char */
int ch = addr->RDR;
int i;
/* special control char ? */
for(i=0; i<sizeof(com[unit].file.cchars); i++){
if(com[unit].file.cchars[i] && ch == com[unit].file.cchars[i]){
sigunblock( com[unit].file.ccpid );
ksendmsg( com[unit].file.ccpid, MSG_CCHAR_0 + i );
return;
}
}
if( com[unit].len < SERIAL_QUEUE_SIZE ){
/* queue it up */
com[unit].queue[ com[unit].head++ ] = ch;
com[unit].head %= SERIAL_QUEUE_SIZE;
com[unit].len ++;
/* flow control */
#if 0
if( com[unit].len > SERIAL_QUEUE_HIWATER ){
/* almost full - drop RTS */
/* com[unit].status |= COMSTAT_THROTTLED; */
}
#endif
wakeup( &com[unit].len );
}
}
}
/* open? write */
ssize_t sendto(int sockfd, const void *buff, size_t size,
int flags, const struct sockaddr *addr,
socklen_t addrlen) {
int ret;
struct msghdr msg;
struct iovec iov;
struct sock *sk;
socket_idesc_check(sockfd, sk);
if (sk->shutdown_flag & (SHUT_WR + 1))
return SET_ERRNO(EPIPE);
// if (!size)
// return 0;
/* TODO remove this */
if (flags != 0) {
LOG_ERROR("sendto", "flags are not supported");
return SET_ERRNO(EOPNOTSUPP);
}
msg.msg_name = (void *)addr;
msg.msg_namelen = addrlen;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_flags = flags;
iov.iov_base = (void *)buff;
iov.iov_len = size;
ret = ksendmsg(sk, &msg, sk->idesc.idesc_flags);
if (ret < 0) {
return SET_ERRNO(-ret);
}
return ret;
}
void
kbdirq(struct intrframe *fr){
int c, i;
const char *cs=0;
struct Kbd *k = &term.kbd; /* we only support one, for now */
c = inb( k->port );
/* make or break */
if( c & 0x80 ){
/* break */
c &= 0x7f;
switch( scan_codes[c].type ){
case SCROLL:
k->state &= ~SCROLL;
break;
case SHIFT:
k->state &= ~SHIFT;
break;
case ALT:
k->state &= ~ALT;
break;
case CTL:
k->state &= ~CTL;
break;
}
}else{
/* make */
switch( scan_codes[c].type ){
case SHIFT:
k->state |= SHIFT;
break;
case ALT:
k->state |= ALT;
break;
case CTL:
k->state |= CTL;
break;
case NUM:
k->state ^= NUM;
break;
case CAPS:
k->state ^= CAPS;
break;
case NONE:
break;
case ASCII:
case FUNC:
if( k->state & CTL )
cs = scan_codes[c].ctl;
else if( k->state & (SHIFT | CAPS) )
cs = scan_codes[c].shift;
else
cs = scan_codes[c].unshift;
break;
case KP:
if( c == 83 && k->state & CTL && k->state & ALT ){
/* ctl-alt-del detected */
#ifdef USE_GDB
if( bootflags & BOOT_USEGDB )
breakpoint();
else
#endif
{
E9PRINTF(("\n<C-A-Del>\nrebooting\n"));
kprintf("\nrebooting...");
reboot();
}
}
if( k->state & CTL )
cs = scan_codes[c].ctl;
else if( k->state & (SHIFT | NUM) )
cs = scan_codes[c].shift;
else
cs = scan_codes[c].unshift;
break;
}
/* special control char ? */
for(i=0; i<sizeof(term.file.cchars); i++){
if(cs && term.file.cchars[i] && *cs == term.file.cchars[i]){
sigunblock( term.file.ccpid );
ksendmsg( term.file.ccpid, MSG_CCHAR_0 + i );
return;
}
}
/* enqueue chars */
while( cs && *cs ){
if( k->len < PCTERM_QUEUE_SIZE ){
k->queue[ k->head++ ] = (k->state & ALT) ? (0x80 | *cs) : *cs;
k->head %= PCTERM_QUEUE_SIZE;
k->len ++;
}
/* else just drop it */
cs++;
}
wakeup(k);
}
}
