p71924506
/
kernel_liteos_a1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
kernel_liteos_a1/syscall/net_syscall.c

633 lines
18 KiB
C
Executable File
Raw Blame History

/*
* Copyright (c) 2013-2019, Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020, Huawei Device Co., Ltd. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
* of conditions and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
* to endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "los_syscall.h"
#include "los_process_pri.h"
#include "lwip/sockets.h"
#include <stdlib.h>
#include "los_vm_map.h"
#include "user_copy.h"
#include "fs_file.h"
#ifdef LOSCFG_NET_LWIP_SACK
#define SOCKET_U2K(s) do { s = GetAssociatedSystemFd(s); } while (0)
#define SOCKET_K2U(s) \
do { \
int fd = AllocAndAssocProcessFd(s, MIN_START_FD); \
if (fd == -1) { \
closesocket(s); \
set_errno(EMFILE); \
s = -EMFILE; \
} else { \
s = fd; \
} \
} while (0)
#define CHECK_ASPACE(ptr, len, ...) \
do { \
if (ptr != NULL && len != 0) { \
if (!LOS_IsUserAddressRange((VADDR_T)ptr, len)) { \
set_errno(EFAULT); \
__VA_ARGS__; \
return -get_errno(); \
} \
if (CheckRegion(OsCurrProcessGet()->vmSpace, (VADDR_T)ptr, len) == -1) { \
set_errno(EFAULT); \
__VA_ARGS__; \
return -get_errno(); \
} \
} \
} while (0)
static int CheckRegion(const LosVmSpace *space, VADDR_T ptr, size_t len)
{
LosVmMapRegion *region = LOS_RegionFind((LosVmSpace *)space, ptr);
if (region == NULL) {
return -1;
}
if (ptr + len <= region->range.base + region->range.size) {
return 0;
}
return CheckRegion(space, region->range.base + region->range.size,
(ptr + len) - (region->range.base + region->range.size));
}
static void *DupUserMem(const void *ptr, size_t len, int needCopy)
{
void *p = malloc(len);
if (p == NULL) {
set_errno(ENOMEM);
return NULL;
}
if (needCopy && LOS_ArchCopyFromUser(p, ptr, len) != 0) {
free(p);
set_errno(EFAULT);
return NULL;
}
return p;
}
#define LEN(ptr) ((ptr) ? *(ptr) : 0)
#define DUP_FROM_USER_(ptr, size, copy, ...) \
__typeof(ptr) ptr##bak = ptr; \
if (ptr != NULL && (size) != 0) { \
ptr = DupUserMem(ptr, size, copy); \
if (ptr == NULL) { \
ptr = ptr##bak; \
__VA_ARGS__; \
return -get_errno(); \
} \
}
#define DUP_FROM_USER(ptr, size, ...) \
DUP_FROM_USER_(ptr, size, 1, ##__VA_ARGS__)
#define DUP_FROM_USER_NOCOPY(ptr, size, ...) \
DUP_FROM_USER_(ptr, size, 0, ##__VA_ARGS__)
#define DUP_TO_USER(ptr, size, ...) \
if (ptr != NULL && (size) != 0) { \
if (LOS_ArchCopyToUser(ptr##bak, ptr, size) != 0) { \
set_errno(EFAULT); \
__VA_ARGS__; \
return -get_errno(); \
} \
}
#define FREE_DUP(ptr) \
if (ptr != ptr##bak) { \
free((void*)ptr); \
ptr = ptr##bak; \
}
#define CPY_FROM_USER(ptr) \
__typeof(*ptr) ptr##cpy = {0}, *ptr##bak = ptr; \
if (ptr != NULL) { \
if (LOS_ArchCopyFromUser((void*)&ptr##cpy, ptr, sizeof(*ptr)) != 0) { \
set_errno(EFAULT); \
return -get_errno(); \
} \
ptr = &ptr##cpy; \
}
#define CPY_TO_USER(ptr, ...) \
if (ptr != NULL) { \
if (LOS_ArchCopyToUser(ptr##bak, ptr, sizeof(*ptr)) != 0) { \
set_errno(EFAULT); \
__VA_ARGS__; \
return -get_errno(); \
} \
}
/** Macros for sendmsg and recvmsg */
#define CONST_CAST(ptr) ((__typeof(ptr##_NONCONST))ptr)
#define CHECK_FIELD_ASPACE(ptr, field, len) \
do { \
if (ptr != NULL) { \
CHECK_ASPACE(ptr->field, len); \
} \
} while (0)
#define CHECK_ARRAY_FIELD_ASPACE(ptr, arr, arrlen, field, len, ...) \
do { \
if (ptr != NULL && ptr->arr != NULL) { \
for (size_t i = 0; i < arrlen; i++) { \
CHECK_ASPACE(ptr->arr[i].field, ptr->arr[i].len, ##__VA_ARGS__); \
} \
} \
} while (0)
#define DUP_FIELD_FROM_USER_(ptr, field, size, copy, ...) \
if (ptr != NULL && ptr->field != NULL && (size) != 0) { \
CONST_CAST(ptr)->field = DupUserMem(ptr->field, size, copy); \
if (ptr->field == NULL) { \
__VA_ARGS__; \
return -get_errno(); \
} \
}
#define DUP_FIELD_FROM_USER(ptr, field, size, ...) \
DUP_FIELD_FROM_USER_(ptr, field, size, 1, ##__VA_ARGS__)
#define DUP_FIELD_FROM_USER_NOCOPY(ptr, field, size, ...) \
DUP_FIELD_FROM_USER_(ptr, field, size, 0, ##__VA_ARGS__)
#define DUP_ARRAY_FIELD_FROM_USER_(ext, ptr, arr, arrlen, field, len, ...) \
/* backup the arr to ptr##arr */ \
__typeof(*ptr##_NONCONST) ptr##arr##cpy = ptr##cpybak, ptr##arr##cpybak = ptr##cpybak; \
__typeof(ptr##_NONCONST) ptr##arr = ptr ? &ptr##arr##cpy : NULL, ptr##arr##_NONCONST = NULL; \
DUP_FIELD_FROM_USER(ptr##arr, arr, arrlen * sizeof(ptr->arr[0]), ##__VA_ARGS__); \
if (ptr != NULL && ptr->arr != NULL) { \
size_t i = 0; \
for (; i < arrlen; i++) { \
DUP_FIELD_FROM_USER##ext(ptr, arr[i].field, ptr->arr[i].len, break); \
} \
if (i != arrlen) { \
FREE_DUP_ARRAY_FIELD(ptr, arr, i, field); \
__VA_ARGS__; \
return -get_errno(); \
} \
}
#define DUP_ARRAY_FIELD_FROM_USER(ptr, arr, arrlen, field, len, ...) \
DUP_ARRAY_FIELD_FROM_USER_(, ptr, arr, arrlen, field, len, ##__VA_ARGS__)
#define DUP_ARRAY_FIELD_FROM_USER_NOCOPY(ptr, arr, arrlen, field, len, ...) \
DUP_ARRAY_FIELD_FROM_USER_(_NOCOPY, ptr, arr, arrlen, field, len, ##__VA_ARGS__)
#define FREE_DUP_FIELD(ptr, field) \
if (ptr != NULL && ptr->field != ptr##cpybak.field) { \
free((void*)ptr->field); \
CONST_CAST(ptr)->field = ptr##cpybak.field; \
}
#define FREE_DUP_ARRAY_FIELD(ptr, arr, arrlen, field) \
/* use and free the backuped arr in ptr##arr */ \
if (ptr != NULL && ptr->arr != NULL && arrlen != 0) { \
__typeof(ptr##cpybak.arr) tmp = ptr##cpybak.arr; \
ptr##cpybak.arr = ptr##arr->arr; \
for (size_t j = 0; j < arrlen; j++) { \
FREE_DUP_FIELD(ptr, arr[j].field); \
} \
ptr##cpybak.arr = tmp; \
} \
FREE_DUP_FIELD(ptr##arr, arr);
#define CPY_FROM_CONST_USER(NonConstType, ptr) \
CPY_FROM_USER(ptr); \
NonConstType *ptr##_NONCONST = NULL, ptr##cpybak = ptr##cpy; \
(void)ptr##bak;
#define CPY_FROM_NONCONST_USER(ptr) \
CPY_FROM_USER(ptr); \
__typeof(*ptr) *ptr##_NONCONST = NULL, ptr##cpybak = ptr##cpy;
#define DUP_FIELD_TO_USER(ptr, field, size, ...) \
if (ptr != NULL && ptr->field != NULL && (size) != 0) { \
if (LOS_ArchCopyToUser(ptr##cpybak.field, ptr->field, size) != 0 || \
LOS_ArchCopyToUser(&ptr##bak->field, &ptr##cpybak.field, sizeof(ptr##cpybak.field)) != 0) { \
set_errno(EFAULT); \
__VA_ARGS__; \
return -get_errno(); \
} \
}
#define DUP_ARRAY_FIELD_TO_USER(ptr, arr, arrlen, field, len, ...) \
/* use the backuped arr from ptr##arr */ \
if (ptr != NULL && ptr->arr != NULL) { \
__typeof(ptr##cpybak.arr) tmp = ptr##cpybak.arr; \
__typeof(ptr##bak) tmp2 = ptr##bak; \
ptr##cpybak.arr = ptr##arr->arr; \
ptr##arr->arr = tmp; \
ptr##bak = ptr##arr; \
for (size_t i = 0; i < arrlen; i++) { \
DUP_FIELD_TO_USER(ptr, arr[i].field, ptr->arr[i].len, ##__VA_ARGS__); \
} \
ptr##bak = tmp2; \
ptr##arr->arr = ptr##cpybak.arr; \
ptr##cpybak.arr = tmp; \
}
int SysSocket(int domain, int type, int protocol)
{
int ret;
ret = socket(domain, type, protocol);
if (ret == -1) {
return -get_errno();
}
SOCKET_K2U(ret);
return ret;
}
int SysBind(int s, const struct sockaddr *name, socklen_t namelen)
{
int ret;
SOCKET_U2K(s);
CHECK_ASPACE(name, namelen);
DUP_FROM_USER(name, namelen);
ret = bind(s, name, namelen);
FREE_DUP(name);
if (ret == -1) {
return -get_errno();
}
return ret;
}
int SysConnect(int s, const struct sockaddr *name, socklen_t namelen)
{
int ret;
SOCKET_U2K(s);
CHECK_ASPACE(name, namelen);
DUP_FROM_USER(name, namelen);
ret = connect(s, name, namelen);
FREE_DUP(name);
if (ret == -1) {
return -get_errno();
}
return ret;
}
int SysListen(int sockfd, int backlog)
{
int ret;
SOCKET_U2K(sockfd);
ret = listen(sockfd, backlog);
if (ret == -1) {
return -get_errno();
}
return ret;
}
int SysAccept(int socket, struct sockaddr *address,
socklen_t *addressLen)
{
int ret;
SOCKET_U2K(socket);
CHECK_ASPACE(addressLen, sizeof(socklen_t));
CPY_FROM_USER(addressLen);
CHECK_ASPACE(address, LEN(addressLen));
DUP_FROM_USER_NOCOPY(address, LEN(addressLen));
ret = accept(socket, address, addressLen);
if (ret == -1) {
FREE_DUP(address);
return -get_errno();
}
CPY_TO_USER(addressLen, close(ret); FREE_DUP(address));
DUP_TO_USER(address, LEN(addressLen), close(ret); FREE_DUP(address));
FREE_DUP(address);
SOCKET_K2U(ret);
return ret;
}
int SysGetSockName (int s, struct sockaddr *name, socklen_t *namelen)
{
int ret;
SOCKET_U2K(s);
CHECK_ASPACE(namelen, sizeof(socklen_t));
CPY_FROM_USER(namelen);
CHECK_ASPACE(name, LEN(namelen));
DUP_FROM_USER_NOCOPY(name, LEN(namelen));
ret = getsockname(s, name, namelen);
if (ret == -1) {
FREE_DUP(name);
return -get_errno();
}
CPY_TO_USER(namelen, FREE_DUP(name));
DUP_TO_USER(name, LEN(namelen), FREE_DUP(name));
FREE_DUP(name);
return ret;
}
int SysGetPeerName (int s, struct sockaddr *name, socklen_t *namelen)
{
int ret;
SOCKET_U2K(s);
CHECK_ASPACE(namelen, sizeof(socklen_t));
CPY_FROM_USER(namelen);
CHECK_ASPACE(name, LEN(namelen));
DUP_FROM_USER_NOCOPY(name, LEN(namelen));
ret = getpeername(s, name, namelen);
if (ret == -1) {
FREE_DUP(name);
return -get_errno();
}
CPY_TO_USER(namelen, FREE_DUP(name));
DUP_TO_USER(name, LEN(namelen), FREE_DUP(name));
FREE_DUP(name);
return ret;
}
ssize_t SysSend(int s, const void *dataptr, size_t size, int flags)
{
int ret;
SOCKET_U2K(s);
CHECK_ASPACE(dataptr, size);
DUP_FROM_USER(dataptr, size);
ret = send(s, dataptr, size, flags);
FREE_DUP(dataptr);
if (ret == -1) {
return -get_errno();
}
return ret;
}
ssize_t SysSendTo(int s, const void *dataptr, size_t size, int flags,
const struct sockaddr *to, socklen_t tolen)
{
int ret;
SOCKET_U2K(s);
CHECK_ASPACE(dataptr, size);
CHECK_ASPACE(to, tolen);
DUP_FROM_USER(dataptr, size);
DUP_FROM_USER(to, tolen, FREE_DUP(dataptr););
ret = sendto(s, dataptr, size, flags, to, tolen);
FREE_DUP(dataptr);
FREE_DUP(to);
if (ret == -1) {
return -get_errno();
}
return ret;
}
ssize_t SysRecv(int socket, void *buffer, size_t length, int flags)
{
int ret;
SOCKET_U2K(socket);
CHECK_ASPACE(buffer, length);
DUP_FROM_USER_NOCOPY(buffer, length);
ret = recv(socket, buffer, length, flags);
if (ret == -1) {
FREE_DUP(buffer);
return -get_errno();
}
DUP_TO_USER(buffer, ret, FREE_DUP(buffer));
FREE_DUP(buffer);
return ret;
}
ssize_t SysRecvFrom(int socket, void *buffer, size_t length,
int flags, struct sockaddr *address,
socklen_t *addressLen)
{
int ret;
SOCKET_U2K(socket);
CHECK_ASPACE(buffer, length);
CHECK_ASPACE(addressLen, sizeof(socklen_t));
CPY_FROM_USER(addressLen);
CHECK_ASPACE(address, LEN(addressLen));
DUP_FROM_USER_NOCOPY(address, LEN(addressLen));
DUP_FROM_USER_NOCOPY(buffer, length, FREE_DUP(address));
ret = recvfrom(socket, buffer, length, flags, address, addressLen);
if (ret == -1) {
FREE_DUP(address);
FREE_DUP(buffer);
return -get_errno();
}
CPY_TO_USER(addressLen, FREE_DUP(address); FREE_DUP(buffer));
DUP_TO_USER(address, LEN(addressLen), FREE_DUP(address); FREE_DUP(buffer));
DUP_TO_USER(buffer, ret, FREE_DUP(address); FREE_DUP(buffer));
FREE_DUP(address);
FREE_DUP(buffer);
return ret;
}
int SysShutdown(int socket, int how)
{
int ret;
SOCKET_U2K(socket);
ret = shutdown(socket, how);
if (ret == -1) {
return -get_errno();
}
return ret;
}
int SysSetSockOpt(int socket, int level, int optName,
const void *optValue, socklen_t optLen)
{
int ret;
SOCKET_U2K(socket);
CHECK_ASPACE(optValue, optLen);
DUP_FROM_USER(optValue, optLen);
ret = setsockopt(socket, level, optName, optValue, optLen);
FREE_DUP(optValue);
if (ret == -1) {
return -get_errno();
}
return ret;
}
int SysGetSockOpt(int sockfd, int level, int optName,
void *optValue, socklen_t *optLen)
{
int ret;
SOCKET_U2K(sockfd);
CHECK_ASPACE(optLen, sizeof(socklen_t));
CPY_FROM_USER(optLen);
CHECK_ASPACE(optValue, LEN(optLen));
DUP_FROM_USER_NOCOPY(optValue, LEN(optLen));
ret = getsockopt(sockfd, level, optName, optValue, optLen);
if (ret == -1) {
FREE_DUP(optValue);
return -get_errno();
}
CPY_TO_USER(optLen, FREE_DUP(optValue));
DUP_TO_USER(optValue, LEN(optLen), FREE_DUP(optValue));
FREE_DUP(optValue);
return ret;
}
ssize_t SysSendMsg(int s, const struct msghdr *message, int flags)
{
int ret;
SOCKET_U2K(s);
CHECK_ASPACE(message, sizeof(struct msghdr));
CPY_FROM_CONST_USER(struct msghdr, message);
if (message && message->msg_iovlen > IOV_MAX) {
set_errno(EMSGSIZE);
return -get_errno();
}
CHECK_FIELD_ASPACE(message, msg_name, message->msg_namelen);
CHECK_FIELD_ASPACE(message, msg_iov, message->msg_iovlen * sizeof(struct iovec));
CHECK_FIELD_ASPACE(message, msg_control, message->msg_controllen);
DUP_FIELD_FROM_USER(message, msg_iov, message->msg_iovlen * sizeof(struct iovec));
CHECK_ARRAY_FIELD_ASPACE(message, msg_iov, message->msg_iovlen, iov_base, iov_len,
FREE_DUP_FIELD(message, msg_iov));
DUP_FIELD_FROM_USER(message, msg_name, message->msg_namelen,
FREE_DUP_FIELD(message, msg_iov));
DUP_FIELD_FROM_USER(message, msg_control, message->msg_controllen,
FREE_DUP_FIELD(message, msg_iov);
FREE_DUP_FIELD(message, msg_name));
DUP_ARRAY_FIELD_FROM_USER(message, msg_iov, message->msg_iovlen, iov_base, iov_len,
FREE_DUP_FIELD(message, msg_control);
FREE_DUP_FIELD(message, msg_iov);
FREE_DUP_FIELD(message, msg_name));
ret = sendmsg(s, message, flags);
FREE_DUP_ARRAY_FIELD(message, msg_iov, message->msg_iovlen, iov_base);
FREE_DUP_FIELD(message, msg_control);
FREE_DUP_FIELD(message, msg_iov);
FREE_DUP_FIELD(message, msg_name);
if (ret == -1) {
return -get_errno();
}
return ret;
}
ssize_t SysRecvMsg(int s, struct msghdr *message, int flags)
{
int ret;
SOCKET_U2K(s);
CHECK_ASPACE(message, sizeof(struct msghdr));
CPY_FROM_NONCONST_USER(message);
if (message && message->msg_iovlen > IOV_MAX) {
set_errno(EMSGSIZE);
return -get_errno();
}
CHECK_FIELD_ASPACE(message, msg_name, message->msg_namelen);
CHECK_FIELD_ASPACE(message, msg_iov, message->msg_iovlen * sizeof(struct iovec));
CHECK_FIELD_ASPACE(message, msg_control, message->msg_controllen);
DUP_FIELD_FROM_USER(message, msg_iov, message->msg_iovlen * sizeof(struct iovec));
CHECK_ARRAY_FIELD_ASPACE(message, msg_iov, message->msg_iovlen, iov_base, iov_len,
FREE_DUP_FIELD(message, msg_iov));
DUP_FIELD_FROM_USER_NOCOPY(message, msg_name, message->msg_namelen,
FREE_DUP_FIELD(message, msg_iov));
DUP_FIELD_FROM_USER_NOCOPY(message, msg_control, message->msg_controllen,
FREE_DUP_FIELD(message, msg_iov);
FREE_DUP_FIELD(message, msg_name));
DUP_ARRAY_FIELD_FROM_USER_NOCOPY(message, msg_iov, message->msg_iovlen, iov_base, iov_len,
FREE_DUP_FIELD(message, msg_control);
FREE_DUP_FIELD(message, msg_iov);
FREE_DUP_FIELD(message, msg_name));
ret = recvmsg(s, message, flags);
if (ret == -1) {
goto OUT;
}
CPY_TO_USER(message, ret = -1; goto OUT);
DUP_FIELD_TO_USER(message, msg_control, message->msg_controllen, ret = -1; goto OUT);
DUP_FIELD_TO_USER(message, msg_iov, message->msg_iovlen * sizeof(struct iovec), ret = -1; goto OUT);
DUP_FIELD_TO_USER(message, msg_name, message->msg_namelen, ret = -1; goto OUT);
DUP_ARRAY_FIELD_TO_USER(message, msg_iov, message->msg_iovlen, iov_base, iov_len, ret = -1; goto OUT);
OUT:
FREE_DUP_ARRAY_FIELD(message, msg_iov, message->msg_iovlen, iov_base);
FREE_DUP_FIELD(message, msg_control);
FREE_DUP_FIELD(message, msg_iov);
FREE_DUP_FIELD(message, msg_name);
return (ret == -1) ? -get_errno() : ret;
}
#endif
Reference in New Issue View Git Blame Copy Permalink