WolfSSL
/
wolfssh
mirror of https://github.com/wolfSSL/wolfssh.git
1
0
Fork 0
Code Issues Releases Wiki Activity
wolfssh/src/io.c

455 lines
12 KiB
C
Raw Blame History

/* io.c
*
* Copyright (C) 2014-2026 wolfSSL Inc.
*
* This file is part of wolfSSH.
*
* wolfSSH is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* wolfSSH is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with wolfSSH. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* The io module provides the default send and receive callbacks used
* by the library to handle network I/O. By default they handle UNIX
* style I/O.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <wolfssh/ssh.h>
#include <wolfssh/internal.h>
#include <wolfssh/log.h>
#ifndef NULL
#include <stddef.h>
#endif
#ifdef WOLFSSH_TEST_BLOCK
#define WOLFSSH_TEST_SERVER
#include "wolfssh/test.h"
/* percent of time that forced want read/write is done */
#ifndef WOLFSSH_BLOCK_PROB
#define WOLFSSH_BLOCK_PROB 50
#endif
#endif
/* allow I/O callback handlers whether user I/O or not */
/* install I/O recv callback */
void wolfSSH_SetIORecv(WOLFSSH_CTX* ctx, WS_CallbackIORecv cb)
{
if (ctx)
ctx->ioRecvCb = cb;
}
/* install I/O send callback */
void wolfSSH_SetIOSend(WOLFSSH_CTX* ctx, WS_CallbackIOSend cb)
{
if (ctx)
ctx->ioSendCb = cb;
}
/* install I/O read context */
void wolfSSH_SetIOReadCtx(WOLFSSH* ssh, void *ctx)
{
if (ssh)
ssh->ioReadCtx = ctx;
}
/* install I/O read context */
void wolfSSH_SetIOWriteCtx(WOLFSSH* ssh, void *ctx)
{
if (ssh)
ssh->ioWriteCtx = ctx;
}
/* get I/O read context */
void* wolfSSH_GetIOReadCtx(WOLFSSH* ssh)
{
if (ssh)
return ssh->ioReadCtx;
return NULL;
}
/* get I/O write context */
void* wolfSSH_GetIOWriteCtx(WOLFSSH* ssh)
{
if (ssh)
return ssh->ioWriteCtx;
return NULL;
}
#ifndef WOLFSSH_USER_IO
/* default I/O callbacks, use BSD style sockets */
#ifndef USE_WINDOWS_API
#ifdef WOLFSSH_LWIP
/* lwIP needs to be configured to use sockets API in this mode */
/* LWIP_SOCKET 1 in lwip/opt.h or in build */
#include "lwip/sockets.h"
#ifndef LWIP_PROVIDE_ERRNO
#include <errno.h>
#define LWIP_PROVIDE_ERRNO 1
#endif
#elif defined(FREESCALE_MQX)
#include <posix.h>
#include <rtcs.h>
#elif defined(WOLFSSH_MDK_ARM)
#if defined(WOLFSSH_MDK5)
#include "cmsis_os.h"
#include "rl_fs.h"
#include "rl_net.h"
#else
#include <rtl.h>
#endif
#undef RNG
#include "WOLFSSH_MDK_ARM.h"
#undef RNG
#define RNG CyaSSL_RNG
/* for avoiding name conflict in "stm32f2xx.h" */
static int errno;
#elif defined(MICROCHIP_MPLAB_HARMONY)
#include "tcpip/tcpip.h"
#include <errno.h>
#elif defined(WOLFSSL_NUCLEUS)
#include "nucleus.h"
#include "networking/nu_networking.h"
#include <errno.h>
#elif defined(WOLFSSH_ZEPHYR)
#include <zephyr/net/socket.h>
#else
#include <sys/types.h>
#include <errno.h>
#ifndef EBSNET
#include <unistd.h>
#endif
#include <fcntl.h>
#if !(defined(DEVKITPRO) || defined(HAVE_RTP_SYS) || defined(EBSNET))
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netdb.h>
#ifdef __PPU
#include <netex/errno.h>
#else
#include <sys/ioctl.h>
#endif
#endif
#ifdef HAVE_RTP_SYS
#include <socket.h>
#endif
#ifdef EBSNET
#include "rtipapi.h" /* errno */
#include "socket.h"
#endif
#endif
#endif /* USE_WINDOWS_API */
#ifdef __sun
#include <sys/filio.h>
#endif
#ifdef USE_WINDOWS_API
/* no epipe yet */
#ifndef WSAEPIPE
#define WSAEPIPE -12345
#endif
#define SOCKET_EWOULDBLOCK WSAEWOULDBLOCK
#define SOCKET_EAGAIN WSAETIMEDOUT
#define SOCKET_ECONNRESET WSAECONNRESET
#define SOCKET_EINTR WSAEINTR
#define SOCKET_EPIPE WSAEPIPE
#define SOCKET_ECONNREFUSED WSAENOTCONN
#define SOCKET_ECONNABORTED WSAECONNABORTED
#define close(s) closesocket(s)
#elif defined(__PPU)
#define SOCKET_EWOULDBLOCK SYS_NET_EWOULDBLOCK
#define SOCKET_EAGAIN SYS_NET_EAGAIN
#define SOCKET_ECONNRESET SYS_NET_ECONNRESET
#define SOCKET_EINTR SYS_NET_EINTR
#define SOCKET_EPIPE SYS_NET_EPIPE
#define SOCKET_ECONNREFUSED SYS_NET_ECONNREFUSED
#define SOCKET_ECONNABORTED SYS_NET_ECONNABORTED
#elif defined(FREESCALE_MQX)
/* RTCS doesn't have an EWOULDBLOCK error */
#define SOCKET_EWOULDBLOCK EAGAIN
#define SOCKET_EAGAIN EAGAIN
#define SOCKET_ECONNRESET RTCSERR_TCP_CONN_RESET
#define SOCKET_EINTR EINTR
#define SOCKET_EPIPE EPIPE
#define SOCKET_ECONNREFUSED RTCSERR_TCP_CONN_REFUSED
#define SOCKET_ECONNABORTED RTCSERR_TCP_CONN_ABORTED
#elif defined(WOLFSSH_MDK_ARM)
#if defined(WOLFSSH_MDK5)
#define SOCKET_EWOULDBLOCK BSD_ERROR_WOULDBLOCK
#define SOCKET_EAGAIN BSD_ERROR_LOCKED
#define SOCKET_ECONNRESET BSD_ERROR_CLOSED
#define SOCKET_EINTR BSD_ERROR
#define SOCKET_EPIPE BSD_ERROR
#define SOCKET_ECONNREFUSED BSD_ERROR
#define SOCKET_ECONNABORTED BSD_ERROR
#else
#define SOCKET_EWOULDBLOCK SCK_EWOULDBLOCK
#define SOCKET_EAGAIN SCK_ELOCKED
#define SOCKET_ECONNRESET SCK_ECLOSED
#define SOCKET_EINTR SCK_ERROR
#define SOCKET_EPIPE SCK_ERROR
#define SOCKET_ECONNREFUSED SCK_ERROR
#define SOCKET_ECONNABORTED SCK_ERROR
#endif
#elif defined(WOLFSSL_NUCLEUS)
#define SOCKET_EWOULDBLOCK NU_WOULD_BLOCK
#define SOCKET_EAGAIN NU_WOULD_BLOCK
#define SOCKET_ECONNRESET NU_NOT_CONNECTED
#define SOCKET_EINTR NU_NOT_CONNECTED
#define SOCKET_EPIPE NU_NOT_CONNECTED
#define SOCKET_ECONNREFUSED NU_CONNECTION_REFUSED
#define SOCKET_ECONNABORTED NU_NOT_CONNECTED
#else
#define SOCKET_EWOULDBLOCK EWOULDBLOCK
#define SOCKET_EAGAIN EAGAIN
#define SOCKET_ECONNRESET ECONNRESET
#define SOCKET_EINTR EINTR
#define SOCKET_EPIPE EPIPE
#define SOCKET_ECONNREFUSED ECONNREFUSED
#define SOCKET_ECONNABORTED ECONNABORTED
#endif /* USE_WINDOWS_API */
#ifdef DEVKITPRO
/* from network.h */
int net_send(int, const void*, int, unsigned int);
int net_recv(int, void*, int, unsigned int);
#define SEND_FUNCTION net_send
#define RECV_FUNCTION net_recv
#elif defined(WOLFSSH_LWIP)
#define SEND_FUNCTION lwip_send
#define RECV_FUNCTION lwip_recv
#elif defined(MICROCHIP_MPLAB_HARMONY)
#define SEND_FUNCTION(socket,buf,sz,flags) \
TCPIP_TCP_ArrayPut((socket),(uint8_t*)(buf),(sz))
#define RECV_FUNCTION(socket,buf,sz,flags) \
TCPIP_TCP_ArrayGet((socket),(uint8_t*)(buf),(sz))
#elif defined(WOLFSSL_NUCLEUS)
#define SEND_FUNCTION NU_Send
#define RECV_FUNCTION NU_Recv
#else
#define SEND_FUNCTION send
#define RECV_FUNCTION recv
#endif
/* Translates return codes returned from send() and recv() if need be. */
static INLINE int wsReturnCode(int old, WS_SOCKET_T sd)
{
WOLFSSH_UNUSED(sd);
#ifdef FREESCALE_MQX
if (old == 0) {
errno = SOCKET_EWOULDBLOCK;
return -1; /* convert to BSD style wouldblock as error */
}
if (old < 0) {
errno = RTCS_geterror(sd);
if (errno == RTCSERR_TCP_CONN_CLOSING)
return 0; /* convert to BSD style closing */
}
#endif
#ifdef MICROCHIP_MPLAB_HARMONY
if (old == 0) {
/* check is still connected */
if (!TCPIP_TCP_IsConnected(sd))
{
return 0;
}
errno = SOCKET_EWOULDBLOCK;
return -1;
}
#endif
return old;
}
static INLINE int wsErrno(void)
{
#ifdef USE_WINDOWS_API
return WSAGetLastError();
#elif defined(EBSNET)
return xn_getlasterror();
#else
return errno;
#endif
}
/* The receive embedded callback
* return : nb bytes read, or error
*/
int wsEmbedRecv(WOLFSSH* ssh, void* data, word32 sz, void* ctx)
{
int recvd;
int err;
WS_SOCKET_T sd = *(WS_SOCKET_T*)ctx;
char* buf = (char*)data;
#ifdef WOLFSSH_TEST_BLOCK
if (tcp_select(sd, 1) == WS_SELECT_RECV_READY &&
(rand() % 100) < WOLFSSH_BLOCK_PROB) {
printf("Forced read block\n");
return WS_CBIO_ERR_WANT_READ;
}
#endif
#ifdef MICROCHIP_MPLAB_HARMONY
/* check is still connected */
if (!TCPIP_TCP_IsConnected(sd))
{
return WS_CBIO_ERR_CONN_CLOSE;
}
/* check for data ready to be read */
if (TCPIP_TCP_GetIsReady(sd) <= 0) {
return WS_CBIO_ERR_WANT_READ;
}
#endif
recvd = (int)RECV_FUNCTION(sd, buf, sz, ssh->rflags);
recvd = wsReturnCode(recvd, sd);
if (recvd < 0) {
err = wsErrno();
WLOG(WS_LOG_DEBUG,"Embed Receive error");
if (err == SOCKET_EWOULDBLOCK || err == SOCKET_EAGAIN) {
WLOG(WS_LOG_DEBUG," Would block");
return WS_CBIO_ERR_WANT_READ;
}
else if (err == SOCKET_ECONNRESET) {
WLOG(WS_LOG_DEBUG," Connection reset");
return WS_CBIO_ERR_CONN_RST;
}
else if (err == SOCKET_EINTR) {
WLOG(WS_LOG_DEBUG," Socket interrupted");
return WS_CBIO_ERR_ISR;
}
else if (err == SOCKET_ECONNREFUSED) {
WLOG(WS_LOG_DEBUG," Connection refused");
return WS_CBIO_ERR_WANT_READ;
}
else if (err == SOCKET_ECONNABORTED) {
WLOG(WS_LOG_DEBUG," Connection aborted");
return WS_CBIO_ERR_CONN_CLOSE;
}
else {
WLOG(WS_LOG_DEBUG," General error");
return WS_CBIO_ERR_GENERAL;
}
}
else if (recvd == 0) {
WLOG(WS_LOG_DEBUG,"Embed receive connection closed");
return WS_CBIO_ERR_CONN_CLOSE;
}
return recvd;
}
/* The send embedded callback
* return : nb bytes sent, or error
*/
int wsEmbedSend(WOLFSSH* ssh, void* data, word32 sz, void* ctx)
{
WS_SOCKET_T sd = *(WS_SOCKET_T*)ctx;
int sent;
int err;
char* buf = (char*)data;
#ifdef WOLFSSH_TEST_BLOCK
if ((rand() % 100) < WOLFSSH_BLOCK_PROB) {
printf("Forced write block\n");
return WS_CBIO_ERR_WANT_WRITE;
}
#endif
WLOG(WS_LOG_DEBUG,"Embed Send trying to send %d", sz);
#ifdef MICROCHIP_MPLAB_HARMONY
/* check is still connected */
if (!TCPIP_TCP_IsConnected(sd))
{
return WS_CBIO_ERR_CONN_CLOSE;
}
/* not enough space to send */
if ((sent = TCPIP_TCP_PutIsReady(sd)) < sz) {
sz = sent;
}
if (sent == 0) {
/* In the case that 0 is returned the main TCP loop needs to be called */
return WS_CBIO_ERR_WANT_WRITE;
}
#endif /* MICROCHIP_MPLAB_HARMONY */
sent = (int)SEND_FUNCTION(sd, buf, sz, ssh->wflags);
sent = wsReturnCode(sent, sd);
if (sent < 0) {
err = wsErrno();
WLOG(WS_LOG_DEBUG,"Embed Send error");
if (err == SOCKET_EWOULDBLOCK || err == SOCKET_EAGAIN) {
WLOG(WS_LOG_DEBUG," Would Block");
return WS_CBIO_ERR_WANT_WRITE;
}
else if (err == SOCKET_ECONNRESET) {
WLOG(WS_LOG_DEBUG," Connection reset");
return WS_CBIO_ERR_CONN_RST;
}
else if (err == SOCKET_EINTR) {
WLOG(WS_LOG_DEBUG," Socket interrupted");
return WS_CBIO_ERR_ISR;
}
else if (err == SOCKET_EPIPE) {
WLOG(WS_LOG_DEBUG," Socket EPIPE");
return WS_CBIO_ERR_CONN_CLOSE;
}
else {
WLOG(WS_LOG_DEBUG," General error %d", err);
return WS_CBIO_ERR_GENERAL;
}
}
WLOG(WS_LOG_DEBUG,"Embed Send sent %d", sent);
return sent;
}
#endif /* WOLFSSH_USER_IO */
Reference in New Issue View Git Blame Copy Permalink