// 接收消息，指定线程
int msg_recv_ex( messenger_t* msger, uint thread, uint flag )
{
const char * dest_name;
size_t len;
int ret;
if( msger->buffer_size < MIN_RECV_BUFFER_SIZE ){
free( msger->buffer );
msger->buffer_size = MIN_RECV_BUFFER_SIZE;
msger->buffer = malloc( msger->buffer_size );
}
len = msger->buffer_size;
if( thread )
msger->session.thread = thread;
else
msger->session.thread = 0;
ret = sys_recv( &msger->session, msger->buffer, &len, flag );
if( ret < 0 ){
if( -ret == ERR_NOBUF ){
free( msger->buffer );
msger->buffer_size = len;
msger->buffer = malloc( msger->buffer_size );
ret = sys_recv( &msger->session, msger->buffer, &len, flag );
}else{
return ret;
}
}
if( msger->bxml )
bxml_free(msger->bxml);
msger->bxml = bxml_parse( msger->buffer );
if( msger->bxml == NULL )
return -ERR_UNKNOWN;
return ret;
}
asmlinkage int sunos_recv(int fd, u32 ubuf, int size, unsigned flags)
{
int ret;
ret = check_nonblock(sys_recv(fd, (void *)A(ubuf), size, flags), fd);
return ret;
}
asmlinkage int sunos_recv(int fd, void __user *ubuf, int size, unsigned flags)
{
int ret;
ret = check_nonblock(sys_recv(fd,ubuf,size,flags),fd);
return ret;
}
static long sys_socketcall(const struct syscall_info* call)
{
switch (call->args[0]) {
case SYS_RECV:
return sys_recv(call);
default:
return traced_raw_syscall(call);
}
}
ssize_t recv(int sockfd, void *buf, size_t len, int flags){
static ssize_t (*sys_recv)(int, void *, size_t, int) = NULL;
if (!sys_recv) {
if (!(*(void **)(&sys_recv) = dlsym(RTLD_NEXT,"recv"))){
perror("cannot fetch system recv\n");
exit(1);
}
}
if (iniparser_getstring(ini, "recv:allow", NULL))
return sys_recv(sockfd, buf, len, flags);
printf("Forbidden use of recv\n");
return -1;
}
int consdrv_main(int argc, char *argv[]) {
int size, index;
sys_thread_id_t id;
char *p;
consdrv_init();
sys_setintr(SOFTVEC_TYPE_SERINTR, consdrv_intr);
while(1) {
id = sys_recv(MLBOX_ID_CONSOUTPUT, &size, &p);
index = p[0] - '0';
consdrv_command(&consreg[index], id, index, size-1, p+1);
sys_memfree(p);
}
return 0;
}
static int fini_socket(void)
{
char buf[32];
int ret = 0;
ret = sys_shutdown(ctl_socket, SHUT_WR);
if (ret)
goto err;
ret = sys_recv(ctl_socket, buf, sizeof(buf), MSG_WAITALL);
if (ret)
goto err;
err:
sys_close(ctl_socket);
ctl_socket = -1;
return ret;
}
asmlinkage long compat_sys_recv(int fd, void __user *buf, size_t len, unsigned int flags)
{
return sys_recv(fd, buf, len, flags | MSG_CMSG_COMPAT);
}
asmlinkage long compat_sys_socketcall(int call, u32 __user *args)
{
int ret;
u32 a[6];
u32 a0, a1;
if (call < SYS_SOCKET || call > SYS_RECVMSG)
return -EINVAL;
if (copy_from_user(a, args, nas[call]))
return -EFAULT;
a0 = a[0];
a1 = a[1];
switch(call) {
case SYS_SOCKET:
ret = sys_socket(a0, a1, a[2]);
break;
case SYS_BIND:
ret = sys_bind(a0, compat_ptr(a1), a[2]);
break;
case SYS_CONNECT:
ret = sys_connect(a0, compat_ptr(a1), a[2]);
break;
case SYS_LISTEN:
ret = sys_listen(a0, a1);
break;
case SYS_ACCEPT:
ret = sys_accept(a0, compat_ptr(a1), compat_ptr(a[2]));
break;
case SYS_GETSOCKNAME:
ret = sys_getsockname(a0, compat_ptr(a1), compat_ptr(a[2]));
break;
case SYS_GETPEERNAME:
ret = sys_getpeername(a0, compat_ptr(a1), compat_ptr(a[2]));
break;
case SYS_SOCKETPAIR:
ret = sys_socketpair(a0, a1, a[2], compat_ptr(a[3]));
break;
case SYS_SEND:
ret = sys_send(a0, compat_ptr(a1), a[2], a[3]);
break;
case SYS_SENDTO:
ret = sys_sendto(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), a[5]);
break;
case SYS_RECV:
ret = sys_recv(a0, compat_ptr(a1), a[2], a[3]);
break;
case SYS_RECVFROM:
ret = sys_recvfrom(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), compat_ptr(a[5]));
break;
case SYS_SHUTDOWN:
ret = sys_shutdown(a0,a1);
break;
case SYS_SETSOCKOPT:
ret = compat_sys_setsockopt(a0, a1, a[2],
compat_ptr(a[3]), a[4]);
break;
case SYS_GETSOCKOPT:
ret = compat_sys_getsockopt(a0, a1, a[2],
compat_ptr(a[3]), compat_ptr(a[4]));
break;
case SYS_SENDMSG:
ret = compat_sys_sendmsg(a0, compat_ptr(a1), a[2]);
break;
case SYS_RECVMSG:
ret = compat_sys_recvmsg(a0, compat_ptr(a1), a[2]);
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
DEFINE_SYSCALL(socketcall, int, call, uintptr_t *, args)
{
if (call < 1 || call > SYS_SENDMMSG)
return -L_EINVAL;
if (!mm_check_read(args, nargs[call]))
return -L_EFAULT;
switch (call)
{
case SYS_SOCKET:
return sys_socket(args[0], args[1], args[2]);
case SYS_BIND:
return sys_bind(args[0], (const struct sockaddr *)args[1], args[2]);
case SYS_CONNECT:
return sys_connect(args[0], (const struct sockaddr *)args[1], args[2]);
case SYS_LISTEN:
return sys_listen(args[0], args[1]);
case SYS_ACCEPT:
return sys_accept(args[0], (struct sockaddr *)args[1], (int *)args[2]);
case SYS_GETSOCKNAME:
return sys_getsockname(args[0], (struct sockaddr *)args[1], (int *)args[2]);
case SYS_GETPEERNAME:
return sys_getpeername(args[0], (struct sockaddr *)args[1], (int *)args[2]);
case SYS_SEND:
return sys_send(args[0], (const void *)args[1], args[2], args[3]);
case SYS_RECV:
return sys_recv(args[0], (void *)args[1], args[2], args[3]);
case SYS_SENDTO:
return sys_sendto(args[0], (const void *)args[1], args[2], args[3], (const struct sockaddr *)args[4], args[5]);
case SYS_RECVFROM:
return sys_recvfrom(args[0], (void *)args[1], args[2], args[3], (struct sockaddr *)args[4], (int *)args[5]);
case SYS_SHUTDOWN:
return sys_shutdown(args[0], args[1]);
case SYS_SETSOCKOPT:
return sys_setsockopt(args[0], args[1], args[2], (const void *)args[3], args[4]);
case SYS_GETSOCKOPT:
return sys_getsockopt(args[0], args[1], args[2], (void *)args[3], (int *)args[4]);
case SYS_SENDMSG:
return sys_sendmsg(args[0], (const struct msghdr *)args[1], args[2]);
case SYS_RECVMSG:
return sys_recvmsg(args[0], (struct msghdr *)args[1], args[2]);
case SYS_ACCEPT4:
return sys_accept4(args[0], (struct sockaddr *)args[1], (int *)args[2], args[3]);
case SYS_SENDMMSG:
return sys_sendmmsg(args[0], (struct mmsghdr *)args[1], args[2], args[3]);
default:
{
log_error("Unimplemented socketcall: %d", call);
return -L_EINVAL;
}
}
}
int
so_socksys(struct socksysreq *req)
{
int err = -EINVAL;
int cmd = req->args[0];
if ((1 << cmd) & ((1 << SO_ACCEPT) | (1 << SO_BIND) | (1 << SO_CONNECT) |
(1 << SO_GETPEERNAME) | (1 << SO_GETSOCKNAME) | (1 << SO_GETSOCKOPT) |
(1 << SO_LISTEN) | (1 << SO_RECV) | (1 << SO_RECVFROM) | (1 << SO_SEND) |
(1 << SO_SENDTO) | (1 << SO_SETSOCKOPT) | (1 << SO_SHUTDOWN) |
(1 << SO_RECVMSG) | (1 << SO_SENDMSG))) {
int fd = req->args[1];
(void) fd;
/* These are all socket related and accept a file (socket) descriptor as their
first argument. In situations where we are incapable of providing back a real
socket, we must here first distinguish if the file descriptor corresponds to a
socket or a stream. */
#if 0
if (it_is_a_socket) {
#endif
/* In this case, we have a real socket from the operating system's
perspective and we can simply pass the arguments to the appropriate
system call. */
#if 0
switch (cmd) {
case SO_ACCEPT:
/* FIXME: 32/64 conversion */
err = sys_accept(fd, (struct sockaddr *) req->args[2],
req->args[3]);
break;
case SO_BIND:
/* FIXME: 32/64 conversion */
err = sys_bind(fd, (struct sockaddr *) req->args[2], req->args[3]);
break;
case SO_CONNECT:
/* FIXME: 32/64 conversion */
err = sys_connect(fd, (struct sockaddr *) req->args[2],
req->args[3]);
break;
case SO_GETPEERNAME:
/* FIXME: 32/64 conversion */
err = sys_getpeername(fd, (struct sockaddr *) req->args[2],
(int *) req->args[3]);
break;
case SO_GETSOCKNAME:
/* FIXME: 32/64 conversion */
err = sys_getsockname(fd, (struct sockaddr *) req->args[2],
(int *) req->args[3]);
break;
case SO_GETSOCKOPT:
/* FIXME: 32/64 conversion */
err = sys_getsockopt(fd, req->args[2], req->args[3],
(char *) req->args[4], (int *) req->args[5]);
break;
case SO_LISTEN:
/* FIXME: 32/64 conversion */
err = sys_listen(fd, req->args[2]);
break;
case SO_RECV:
/* FIXME: 32/64 conversion */
err = sys_recv(fd, (void *) req->args[2], req->args[3],
req->args[4]);
break;
case SO_RECVFROM:
/* FIXME: 32/64 conversion */
err = sys_recvfrom(fd, (void *) req->args[2], req->args[3],
req->args[4], (struct sockaddr *) req->args[5],
(int *) req->args[6]);
break;
case SO_SEND:
/* FIXME: 32/64 conversion */
err = sys_send(fd, (void *) req->args[2], req->args[3],
req->args[4]);
break;
case SO_SENDTO:
/* FIXME: 32/64 conversion */
err = sys_sendto(fd, (void *) req->args[2], req->args[3],
req->args[4], (struct sockaddr *) req->args[5],
req->args[6]);
break;
case SO_SETSOCKOPT:
/* FIXME: 32/64 conversion */
err = sys_setsockopt(fd, req->args[2], req->args[3],
(char *) req->args[4], req->args[5]);
break;
case SO_SHUTDOWN:
/* FIXME: 32/64 conversion */
err = sys_shutdown(fd, req->args[2]);
break;
case SO_RECVMSG:
/* FIXME: 32/64 conversion */
err = sys_recvmsg(fd, (struct msghdr *) req->args[2], req->args[3]);
break;
case SO_SENDMSG:
/* FIXME: 32/64 conversion */
err = sys_sendmsg(fd, (struct msghdr *) req->args[2], req->args[3]);
break;
}
#endif
#if 0
} else {
/* In this case, we do not have a real socket, but have a TPI stream from
the operating system's perspective, and we will directly call the
associated TPI routine. */
switch (cmd) {
case SO_ACCEPT:
/* FIXME: 32/64 conversion */
err = tpi_accept(fd, (struct sockaddr *) req->args[2],
req->args[3]);
break;
case SO_BIND:
/* FIXME: 32/64 conversion */
err = tpi_bind(fd, (struct sockaddr *) req->args[2], req->args[3]);
break;
case SO_CONNECT:
/* FIXME: 32/64 conversion */
err = tpi_connect(fd, (struct sockaddr *) req->args[2],
req->args[3]);
break;
case SO_GETPEERNAME:
/* FIXME: 32/64 conversion */
err = tpi_getpeername(fd, (struct sockaddr *) req->args[2],
(int *) req->args[3]);
break;
case SO_GETSOCKNAME:
/* FIXME: 32/64 conversion */
err = tpi_getsockname(fd, (struct sockaddr *) req->args[2],
(int *) req->args[3]);
break;
case SO_GETSOCKOPT:
/* FIXME: 32/64 conversion */
err = tpi_getsockopt(fd, req->args[2], req->args[3],
(char *) req->args[4], (int *) req->args[5]);
break;
case SO_LISTEN:
/* FIXME: 32/64 conversion */
err = tpi_listen(fd, req->args[2]);
break;
case SO_RECV:
/* FIXME: 32/64 conversion */
err = tpi_recv(fd, (void *) req->args[2], req->args[3],
req->args[4]);
break;
case SO_RECVFROM:
/* FIXME: 32/64 conversion */
err = tpi_recvfrom(fd, (void *) req->args[2], req->args[3],
req->args[4], (struct sockaddr *) req->args[5],
(int *) req->args[6]);
break;
case SO_SEND:
/* FIXME: 32/64 conversion */
err = tpi_send(fd, (void *) req->args[2], req->args[3],
req->args[4]);
break;
case SO_SENDTO:
/* FIXME: 32/64 conversion */
err = tpi_sendto(fd, (void *) req->args[2], req->args[3],
req->args[4], (struct sockaddr *) req->args[5],
req->args[6]);
break;
case SO_SETSOCKOPT:
/* FIXME: 32/64 conversion */
err = tpi_setsockopt(fd, req->args[2], req->args[3],
(char *) req->args[4], req->args[5]);
break;
case SO_SHUTDOWN:
/* FIXME: 32/64 conversion */
err = tpi_shutdown(fd, req->args[2]);
break;
case SO_RECVMSG:
/* FIXME: 32/64 conversion */
err = tpi_recvmsg(fd, (struct msghdr *) req->args[2], req->args[3]);
break;
case SO_SENDMSG:
/* FIXME: 32/64 conversion */
err = tpi_sendmsg(fd, (struct msghdr *) req->args[2], req->args[3]);
break;
}
}
#endif
}
if ((1 << cmd) & ((1 << SO_SOCKET) | (1 << SO_SOCKPAIR) | (1 << SO_SELECT) |
(1 << SO_GETIPDOMAIN) | (1 << SO_SETIPDOMAIN) | (1 << SO_ADJTIME) |
(1 << SO_SETREUID) | (1 << SO_SETREGID) | (1 << SO_GETTIME) |
(1 << SO_SETTIME) | (1 << SO_GETITIMER) | (1 << SO_SETITIMER))) {
/* These are BSD compatibiltiy functions and are how we create sockets in the first
place. The BSD compatibility functions all have system calls in Linux, but we
provide them for backward compatibility (to what!?). */
#if 0
switch (cmd) {
case SO_SOCKET:
/* FIXME: 32/64 conversion */
/* XXX: don't think so..., after checking for a stream */
err = sys_socket(req->args[1], req->args[2], req->args[3]);
break;
case SO_SOCKPAIR:
/* FIXME: 32/64 conversion */
/* XXX: don't think so..., after checking for a stream */
err = sys_socketpair(req->args[1], req->args[2], req->args[3],
(int *) req->args[4]);
err = -EOPNOTSUPP;
break;
case SO_SELECT:
/* FIXME: 32/64 conversion */
err = sys_select(req->args[1], (fd_set *) req->args[2],
(fd_set *) req->args[3], (fd_set *) req->args[4],
(struct timeval *) req->args[5]);
break;
case SO_GETIPDOMAIN:
/* FIXME: 32/64 conversion */
todo(("Process SO_GETIPDOMAIN for compatibility.\n"));
/* does not exist in Linux, need to use sys_newuname and copy the
domainname portion */
err = -ENOSYS;
break;
case SO_SETIPDOMAIN:
/* FIXME: 32/64 conversion */
err = sys_setdomainname((char *) req->args[1], req->args[2]);
break;
case SO_ADJTIME:
/* FIXME: 32/64 conversion */
err = sys_admtimex((struct timex *) req->args[1]);
break;
case SO_SETREUID:
/* FIXME: 32/64 conversion */
err = sys_setreuid(req->args[1], req->args[2]);
break;
case SO_SETREGID:
/* FIXME: 32/64 conversion */
err = sys_setregid(req->args[1], req->args[2]);
break;
case SO_GETTIME:
/* FIXME: 32/64 conversion */
err = sys_gettimeofday((struct timeval *) req->args[1],
(struct timezone *) req->args[2]);
break;
case SO_SETTIME:
/* FIXME: 32/64 conversion */
err = sys_settimeofday((struct timeval *) req->args[1],
(struct timezone *) req->args[2]);
break;
case SO_GETITIMER:
/* FIXME: 32/64 conversion */
err = sys_getitimer(req->args[1], (struct itimerval *) req->args[2]);
break;
case SO_SETITIMER:
/* FIXME: 32/64 conversion */
err = sys_getitimer(req->args[1], (struct itimerval *) req->args[2],
(struct itimerval *) req->args[3]);
break;
}
#endif
}
return (err);
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
//panic("syscall not implemented");
int32_t rslt;
switch (syscallno) {
case SYS_cputs:
sys_cputs((char *)a1, a2);
rslt = 0;
break;
case SYS_cgetc:
rslt = sys_cgetc();
break;
case SYS_getenvid:
rslt = sys_getenvid();
break;
case SYS_env_destroy:
rslt = sys_env_destroy(a1);
break;
case SYS_yield:
sys_yield();
rslt = 0;
break;
case SYS_exofork:
rslt = sys_exofork();
break;
case SYS_page_alloc:
rslt = sys_page_alloc(a1, (void*)a2, a3);
break;
case SYS_page_map:
rslt = sys_page_map(a1, (void *)a2, a3, (void *)a4, a5);
break;
case SYS_page_unmap:
rslt = sys_page_unmap(a1, (void *)a2);
break;
case SYS_env_set_status:
rslt = sys_env_set_status(a1, a2);
break;
case SYS_env_set_pgfault_upcall:
rslt = sys_env_set_pgfault_upcall(a1, (void *)a2);
break;
case SYS_ipc_try_send:
rslt = sys_ipc_try_send(a1, a2, (void *)a3, a4);
break;
case SYS_ipc_recv:
rslt = sys_ipc_recv((void *)a1);
break;
case SYS_env_set_trapframe:
rslt = sys_env_set_trapframe(a1, (void *)a2);
break;
case SYS_time_msec:
rslt = sys_time_msec();
break;
case SYS_transmit:
rslt = sys_transmit((void *)a1);
break;
case SYS_recv:
rslt = sys_recv((void *)a1);
break;
default:
return -E_INVAL;
}
return rslt;
}
COMPAT_SYSCALL_DEFINE4(recv, int, fd, void __user *, buf, compat_size_t, len, unsigned int, flags)
{
return sys_recv(fd, buf, len, flags | MSG_CMSG_COMPAT);
}
/*
* system call vectors. since i want to rewrite sockets as streams, we have
* this level of indirection. not a lot of overhead, since more of the work is
* done via read/write/select directly
*/
int
sys_socketcall(int call, unsigned long *args)
{
switch (call) {
case SYS_SOCKET:
verify_area(args, 3 * sizeof(long));
return sock_socket(get_fs_long(args+0),
get_fs_long(args+1),
get_fs_long(args+2));
case SYS_BIND:
verify_area(args, 3 * sizeof(long));
return sock_bind(get_fs_long(args+0),
(struct sockaddr *)get_fs_long(args+1),
get_fs_long(args+2));
case SYS_CONNECT:
verify_area(args, 3 * sizeof(long));
return sock_connect(get_fs_long(args+0),
(struct sockaddr *)get_fs_long(args+1),
get_fs_long(args+2));
case SYS_LISTEN:
verify_area(args, 2 * sizeof(long));
return sock_listen(get_fs_long(args+0),
get_fs_long(args+1));
case SYS_ACCEPT:
verify_area(args, 3 * sizeof(long));
return sock_accept(get_fs_long(args+0),
(struct sockaddr *)get_fs_long(args+1),
(int *)get_fs_long(args+2));
case SYS_GETSOCKNAME:
verify_area(args, 3 * sizeof(long));
return sock_getsockname(get_fs_long(args+0),
(struct sockaddr *)get_fs_long(args+1),
(int *)get_fs_long(args+2));
case SYS_GETPEERNAME:
verify_area(args, 3 * sizeof(long));
return sock_getpeername(get_fs_long(args+0),
(struct sockaddr *)get_fs_long(args+1),
(int *)get_fs_long(args+2));
case SYS_SOCKETPAIR:
verify_area(args, 4 * sizeof(long));
return sock_socketpair(get_fs_long(args+0),
get_fs_long(args+1),
get_fs_long(args+2),
(int *)get_fs_long(args+3));
case SYS_SEND:
verify_area(args, 4 * sizeof (unsigned long));
return ( sys_send (get_fs_long(args+0),
(void *)get_fs_long(args+1),
get_fs_long(args+2),
get_fs_long(args+3)));
case SYS_SENDTO:
verify_area(args, 6 * sizeof (unsigned long));
return ( sys_sendto (get_fs_long(args+0),
(void *)get_fs_long(args+1),
get_fs_long(args+2),
get_fs_long(args+3),
(struct sockaddr *)get_fs_long(args+4),
get_fs_long(args+5)));
case SYS_RECV:
verify_area(args, 4 * sizeof (unsigned long));
return ( sys_recv (get_fs_long(args+0),
(void *)get_fs_long(args+1),
get_fs_long(args+2),
get_fs_long(args+3)));
case SYS_RECVFROM:
verify_area(args, 6 * sizeof (unsigned long));
return ( sys_recvfrom (get_fs_long(args+0),
(void *)get_fs_long(args+1),
get_fs_long(args+2),
get_fs_long(args+3),
(struct sockaddr *)get_fs_long(args+4),
(int *)get_fs_long(args+5)));
case SYS_SHUTDOWN:
verify_area (args, 2* sizeof (unsigned long));
return ( sys_shutdown (get_fs_long (args+0),
get_fs_long (args+1)));
case SYS_SETSOCKOPT:
verify_area (args, 5*sizeof (unsigned long));
return (sys_setsockopt (get_fs_long (args+0),
get_fs_long (args+1),
get_fs_long (args+2),
(char *)get_fs_long (args+3),
get_fs_long (args+4)));
case SYS_GETSOCKOPT:
verify_area (args, 5*sizeof (unsigned long));
return (sys_getsockopt (get_fs_long (args+0),
get_fs_long (args+1),
get_fs_long (args+2),
(char *)get_fs_long (args+3),
(int *)get_fs_long (args+4)));
default:
return -EINVAL;
}
}
