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

Merge pull request #321 from ejohnstown/nobreak 

Rename the FALL_THROUGH macro as NO_BREAK as a better descriptor.
pull/323/head
JacobBarthelmeh 2021-02-04 01:49:14 +07:00 committed by GitHub
parent 0d841d2fa0 c9bced2a2b
commit 3326c4bd0d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 109 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/internal.c
View File

@ -5813,8 +5813,7 @@ int DoReceive(WOLFSSH* ssh)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
} }
FALL_THROUGH; NO_BREAK;
/* no break */
case PROCESS_PACKET_LENGTH: case PROCESS_PACKET_LENGTH:
if (ssh->inputBuffer.idx + UINT32_SZ > if (ssh->inputBuffer.idx + UINT32_SZ >
@ -5832,8 +5831,7 @@ int DoReceive(WOLFSSH* ssh)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
ssh->processReplyState = PROCESS_PACKET_FINISH; ssh->processReplyState = PROCESS_PACKET_FINISH;
FALL_THROUGH; NO_BREAK;
/* no break */
case PROCESS_PACKET_FINISH: case PROCESS_PACKET_FINISH:
readSz = ssh->curSz + LENGTH_SZ + peerMacSz; readSz = ssh->curSz + LENGTH_SZ + peerMacSz;
@ -5904,8 +5902,7 @@ int DoReceive(WOLFSSH* ssh)
} }
} }
ssh->processReplyState = PROCESS_PACKET; ssh->processReplyState = PROCESS_PACKET;
FALL_THROUGH; NO_BREAK;
/* no break */
case PROCESS_PACKET: case PROCESS_PACKET:
ret = DoPacket(ssh); ret = DoPacket(ssh);

75
src/ssh.c
View File

@ -416,8 +416,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
} }
ssh->acceptState = ACCEPT_SERVER_VERSION_SENT; ssh->acceptState = ACCEPT_SERVER_VERSION_SENT;
WLOG(WS_LOG_DEBUG, acceptState, "SERVER_VERSION_SENT"); WLOG(WS_LOG_DEBUG, acceptState, "SERVER_VERSION_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_SERVER_VERSION_SENT: case ACCEPT_SERVER_VERSION_SENT:
while (ssh->clientState < CLIENT_VERSION_DONE) { while (ssh->clientState < CLIENT_VERSION_DONE) {
@ -429,8 +428,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
} }
ssh->acceptState = ACCEPT_CLIENT_VERSION_DONE; ssh->acceptState = ACCEPT_CLIENT_VERSION_DONE;
WLOG(WS_LOG_DEBUG, acceptState, "CLIENT_VERSION_DONE"); WLOG(WS_LOG_DEBUG, acceptState, "CLIENT_VERSION_DONE");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_CLIENT_VERSION_DONE: case ACCEPT_CLIENT_VERSION_DONE:
if ( (ssh->error = SendKexInit(ssh)) < WS_SUCCESS) { if ( (ssh->error = SendKexInit(ssh)) < WS_SUCCESS) {
@ -440,8 +438,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
} }
ssh->acceptState = ACCEPT_SERVER_KEXINIT_SENT; ssh->acceptState = ACCEPT_SERVER_KEXINIT_SENT;
WLOG(WS_LOG_DEBUG, acceptState, "SERVER_KEXINIT_SENT"); WLOG(WS_LOG_DEBUG, acceptState, "SERVER_KEXINIT_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_SERVER_KEXINIT_SENT: case ACCEPT_SERVER_KEXINIT_SENT:
while (ssh->isKeying) { while (ssh->isKeying) {
@ -453,8 +450,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
} }
ssh->acceptState = ACCEPT_KEYED; ssh->acceptState = ACCEPT_KEYED;
WLOG(WS_LOG_DEBUG, acceptState, "KEYED"); WLOG(WS_LOG_DEBUG, acceptState, "KEYED");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_KEYED: case ACCEPT_KEYED:
while (ssh->clientState < CLIENT_USERAUTH_REQUEST_DONE) { while (ssh->clientState < CLIENT_USERAUTH_REQUEST_DONE) {
@ -466,8 +462,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
} }
ssh->acceptState = ACCEPT_CLIENT_USERAUTH_REQUEST_DONE; ssh->acceptState = ACCEPT_CLIENT_USERAUTH_REQUEST_DONE;
WLOG(WS_LOG_DEBUG, acceptState, "CLIENT_USERAUTH_REQUEST_DONE"); WLOG(WS_LOG_DEBUG, acceptState, "CLIENT_USERAUTH_REQUEST_DONE");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_CLIENT_USERAUTH_REQUEST_DONE: case ACCEPT_CLIENT_USERAUTH_REQUEST_DONE:
if ( (ssh->error = SendServiceAccept(ssh, if ( (ssh->error = SendServiceAccept(ssh,
@ -479,8 +474,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
ssh->acceptState = ACCEPT_SERVER_USERAUTH_ACCEPT_SENT; ssh->acceptState = ACCEPT_SERVER_USERAUTH_ACCEPT_SENT;
WLOG(WS_LOG_DEBUG, acceptState, WLOG(WS_LOG_DEBUG, acceptState,
"ACCEPT_SERVER_USERAUTH_ACCEPT_SENT"); "ACCEPT_SERVER_USERAUTH_ACCEPT_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_SERVER_USERAUTH_ACCEPT_SENT: case ACCEPT_SERVER_USERAUTH_ACCEPT_SENT:
while (ssh->clientState < CLIENT_USERAUTH_DONE) { while (ssh->clientState < CLIENT_USERAUTH_DONE) {
@ -492,8 +486,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
} }
ssh->acceptState = ACCEPT_CLIENT_USERAUTH_DONE; ssh->acceptState = ACCEPT_CLIENT_USERAUTH_DONE;
WLOG(WS_LOG_DEBUG, acceptState, "CLIENT_USERAUTH_DONE"); WLOG(WS_LOG_DEBUG, acceptState, "CLIENT_USERAUTH_DONE");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_CLIENT_USERAUTH_DONE: case ACCEPT_CLIENT_USERAUTH_DONE:
if ( (ssh->error = SendUserAuthSuccess(ssh)) < WS_SUCCESS) { if ( (ssh->error = SendUserAuthSuccess(ssh)) < WS_SUCCESS) {
@ -503,8 +496,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
} }
ssh->acceptState = ACCEPT_SERVER_USERAUTH_SENT; ssh->acceptState = ACCEPT_SERVER_USERAUTH_SENT;
WLOG(WS_LOG_DEBUG, acceptState, "SERVER_USERAUTH_SENT"); WLOG(WS_LOG_DEBUG, acceptState, "SERVER_USERAUTH_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_SERVER_USERAUTH_SENT: case ACCEPT_SERVER_USERAUTH_SENT:
while (ssh->clientState < CLIENT_CHANNEL_OPEN_DONE) { while (ssh->clientState < CLIENT_CHANNEL_OPEN_DONE) {
@ -516,8 +508,7 @@ int wolfSSH_accept(WOLFSSH* ssh)
} }
ssh->acceptState = ACCEPT_SERVER_CHANNEL_ACCEPT_SENT; ssh->acceptState = ACCEPT_SERVER_CHANNEL_ACCEPT_SENT;
WLOG(WS_LOG_DEBUG, acceptState, "SERVER_CHANNEL_ACCEPT_SENT"); WLOG(WS_LOG_DEBUG, acceptState, "SERVER_CHANNEL_ACCEPT_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case ACCEPT_SERVER_CHANNEL_ACCEPT_SENT: case ACCEPT_SERVER_CHANNEL_ACCEPT_SENT:
while (ssh->clientState < CLIENT_DONE) { while (ssh->clientState < CLIENT_DONE) {
@ -680,8 +671,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_CLIENT_VERSION_SENT; ssh->connectState = CONNECT_CLIENT_VERSION_SENT;
WLOG(WS_LOG_DEBUG, connectState, "CLIENT_VERSION_SENT"); WLOG(WS_LOG_DEBUG, connectState, "CLIENT_VERSION_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_CLIENT_VERSION_SENT: case CONNECT_CLIENT_VERSION_SENT:
while (ssh->serverState < SERVER_VERSION_DONE) { while (ssh->serverState < SERVER_VERSION_DONE) {
@ -693,8 +683,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_SERVER_VERSION_DONE; ssh->connectState = CONNECT_SERVER_VERSION_DONE;
WLOG(WS_LOG_DEBUG, connectState, "SERVER_VERSION_DONE"); WLOG(WS_LOG_DEBUG, connectState, "SERVER_VERSION_DONE");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_SERVER_VERSION_DONE: case CONNECT_SERVER_VERSION_DONE:
if ( (ssh->error = SendKexInit(ssh)) < WS_SUCCESS) { if ( (ssh->error = SendKexInit(ssh)) < WS_SUCCESS) {
@ -704,8 +693,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_CLIENT_KEXINIT_SENT; ssh->connectState = CONNECT_CLIENT_KEXINIT_SENT;
WLOG(WS_LOG_DEBUG, connectState, "CLIENT_KEXINIT_SENT"); WLOG(WS_LOG_DEBUG, connectState, "CLIENT_KEXINIT_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_CLIENT_KEXINIT_SENT: case CONNECT_CLIENT_KEXINIT_SENT:
while (ssh->serverState < SERVER_KEXINIT_DONE) { while (ssh->serverState < SERVER_KEXINIT_DONE) {
@ -717,8 +705,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_SERVER_KEXINIT_DONE; ssh->connectState = CONNECT_SERVER_KEXINIT_DONE;
WLOG(WS_LOG_DEBUG, connectState, "SERVER_KEXINIT_DONE"); WLOG(WS_LOG_DEBUG, connectState, "SERVER_KEXINIT_DONE");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_SERVER_KEXINIT_DONE: case CONNECT_SERVER_KEXINIT_DONE:
if (ssh->handshake == NULL) { if (ssh->handshake == NULL) {
@ -739,8 +726,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_CLIENT_KEXDH_INIT_SENT; ssh->connectState = CONNECT_CLIENT_KEXDH_INIT_SENT;
WLOG(WS_LOG_DEBUG, connectState, "CLIENT_KEXDH_INIT_SENT"); WLOG(WS_LOG_DEBUG, connectState, "CLIENT_KEXDH_INIT_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_CLIENT_KEXDH_INIT_SENT: case CONNECT_CLIENT_KEXDH_INIT_SENT:
while (ssh->isKeying) { while (ssh->isKeying) {
@ -752,8 +738,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_KEYED; ssh->connectState = CONNECT_KEYED;
WLOG(WS_LOG_DEBUG, connectState, "KEYED"); WLOG(WS_LOG_DEBUG, connectState, "KEYED");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_KEYED: case CONNECT_KEYED:
if ( (ssh->error = SendServiceRequest(ssh, ID_SERVICE_USERAUTH)) < if ( (ssh->error = SendServiceRequest(ssh, ID_SERVICE_USERAUTH)) <
@ -763,8 +748,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_CLIENT_USERAUTH_REQUEST_SENT; ssh->connectState = CONNECT_CLIENT_USERAUTH_REQUEST_SENT;
WLOG(WS_LOG_DEBUG, connectState, "CLIENT_USERAUTH_REQUEST_SENT"); WLOG(WS_LOG_DEBUG, connectState, "CLIENT_USERAUTH_REQUEST_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_CLIENT_USERAUTH_REQUEST_SENT: case CONNECT_CLIENT_USERAUTH_REQUEST_SENT:
while (ssh->serverState < SERVER_USERAUTH_REQUEST_DONE) { while (ssh->serverState < SERVER_USERAUTH_REQUEST_DONE) {
@ -776,8 +760,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_SERVER_USERAUTH_REQUEST_DONE; ssh->connectState = CONNECT_SERVER_USERAUTH_REQUEST_DONE;
WLOG(WS_LOG_DEBUG, connectState, "SERVER_USERAUTH_REQUEST_DONE"); WLOG(WS_LOG_DEBUG, connectState, "SERVER_USERAUTH_REQUEST_DONE");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_SERVER_USERAUTH_REQUEST_DONE: case CONNECT_SERVER_USERAUTH_REQUEST_DONE:
#ifdef WOLFSSH_AGENT #ifdef WOLFSSH_AGENT
@ -798,8 +781,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_CLIENT_USERAUTH_SENT; ssh->connectState = CONNECT_CLIENT_USERAUTH_SENT;
WLOG(WS_LOG_DEBUG, connectState, "CLIENT_USERAUTH_SENT"); WLOG(WS_LOG_DEBUG, connectState, "CLIENT_USERAUTH_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_CLIENT_USERAUTH_SENT: case CONNECT_CLIENT_USERAUTH_SENT:
while (ssh->serverState < SERVER_USERAUTH_ACCEPT_DONE) { while (ssh->serverState < SERVER_USERAUTH_ACCEPT_DONE) {
@ -811,8 +793,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
} }
ssh->connectState = CONNECT_SERVER_USERAUTH_ACCEPT_DONE; ssh->connectState = CONNECT_SERVER_USERAUTH_ACCEPT_DONE;
WLOG(WS_LOG_DEBUG, connectState, "SERVER_USERAUTH_ACCEPT_DONE"); WLOG(WS_LOG_DEBUG, connectState, "SERVER_USERAUTH_ACCEPT_DONE");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_SERVER_USERAUTH_ACCEPT_DONE: case CONNECT_SERVER_USERAUTH_ACCEPT_DONE:
{ {
@ -844,8 +825,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
ssh->connectState = CONNECT_CLIENT_CHANNEL_OPEN_SESSION_SENT; ssh->connectState = CONNECT_CLIENT_CHANNEL_OPEN_SESSION_SENT;
WLOG(WS_LOG_DEBUG, connectState, WLOG(WS_LOG_DEBUG, connectState,
"CLIENT_CHANNEL_OPEN_SESSION_SENT"); "CLIENT_CHANNEL_OPEN_SESSION_SENT");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_CLIENT_CHANNEL_OPEN_SESSION_SENT: case CONNECT_CLIENT_CHANNEL_OPEN_SESSION_SENT:
while (ssh->serverState < SERVER_CHANNEL_OPEN_DONE) { while (ssh->serverState < SERVER_CHANNEL_OPEN_DONE) {
@ -858,8 +838,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
ssh->connectState = CONNECT_SERVER_CHANNEL_OPEN_SESSION_DONE; ssh->connectState = CONNECT_SERVER_CHANNEL_OPEN_SESSION_DONE;
WLOG(WS_LOG_DEBUG, connectState, WLOG(WS_LOG_DEBUG, connectState,
"SERVER_CHANNEL_OPEN_SESSION_DONE"); "SERVER_CHANNEL_OPEN_SESSION_DONE");
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_SERVER_CHANNEL_OPEN_SESSION_DONE: case CONNECT_SERVER_CHANNEL_OPEN_SESSION_DONE:
#ifdef WOLFSSH_AGENT #ifdef WOLFSSH_AGENT
@ -891,8 +870,7 @@ int wolfSSH_connect(WOLFSSH* ssh)
WLOG(WS_LOG_DEBUG, connectState, WLOG(WS_LOG_DEBUG, connectState,
"CLIENT_CHANNEL_TERMINAL_REQUEST_SENT"); "CLIENT_CHANNEL_TERMINAL_REQUEST_SENT");
ssh->connectState = CONNECT_CLIENT_CHANNEL_TERMINAL_REQUEST_SENT; ssh->connectState = CONNECT_CLIENT_CHANNEL_TERMINAL_REQUEST_SENT;
FALL_THROUGH; NO_BREAK;
/* no break */
case CONNECT_CLIENT_CHANNEL_TERMINAL_REQUEST_SENT: case CONNECT_CLIENT_CHANNEL_TERMINAL_REQUEST_SENT:
if ( (ssh->error = SendChannelRequest(ssh, ssh->channelName, if ( (ssh->error = SendChannelRequest(ssh, ssh->channelName,
@ -902,9 +880,9 @@ int wolfSSH_connect(WOLFSSH* ssh)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
ssh->connectState = CONNECT_CLIENT_CHANNEL_REQUEST_SENT; ssh->connectState = CONNECT_CLIENT_CHANNEL_REQUEST_SENT;
WLOG(WS_LOG_DEBUG, connectState, "CLIENT_CHANNEL_REQUEST_SENT"); WLOG(WS_LOG_DEBUG, connectState,
FALL_THROUGH; "CLIENT_CHANNEL_REQUEST_SENT");
/* no break */ NO_BREAK;
case CONNECT_CLIENT_CHANNEL_REQUEST_SENT: case CONNECT_CLIENT_CHANNEL_REQUEST_SENT:
while (ssh->serverState < SERVER_DONE) { while (ssh->serverState < SERVER_DONE) {
@ -1291,8 +1269,7 @@ int wolfSSH_SetChannelType(WOLFSSH* ssh, byte type, byte* name, word32 nameSz)
WLOG(WS_LOG_DEBUG, "Server side exec unsupported"); WLOG(WS_LOG_DEBUG, "Server side exec unsupported");
return WS_BAD_ARGUMENT; return WS_BAD_ARGUMENT;
} }
FALL_THROUGH; NO_BREAK;
/* no break */
case WOLFSSH_SESSION_SUBSYSTEM: case WOLFSSH_SESSION_SUBSYSTEM:
ssh->connectChannelId = type; ssh->connectChannelId = type;

12
src/wolfscp.c
View File

@ -1309,8 +1309,7 @@ int ReceiveScpMessage(WOLFSSH* ssh)
switch (buf[0]) { switch (buf[0]) {
case 'C': case 'C':
FALL_THROUGH; NO_BREAK;
/* no break */
case 'D': case 'D':
if (buf[0] == 'C') { if (buf[0] == 'C') {
@ -1422,8 +1421,7 @@ int SendScpConfirmation(WOLFSSH* ssh)
case WS_SCP_CONTINUE: case WS_SCP_CONTINUE:
/* default to ok confirmation */ /* default to ok confirmation */
FALL_THROUGH; NO_BREAK;
/* no break */
default: default:
msg[0] = SCP_CONFIRM_OK; msg[0] = SCP_CONFIRM_OK;
@ -1474,11 +1472,9 @@ int ReceiveScpConfirmation(WOLFSSH* ssh)
case SCP_CONFIRM_OK: case SCP_CONFIRM_OK:
break; break;
case SCP_CONFIRM_ERR: case SCP_CONFIRM_ERR:
FALL_THROUGH; NO_BREAK;
/* no break */
case SCP_CONFIRM_FATAL: case SCP_CONFIRM_FATAL:
FALL_THROUGH; NO_BREAK;
/* no break */
default: default:
WLOG(WS_LOG_ERROR, WLOG(WS_LOG_ERROR,
"scp error: peer sent error confirmation (code: %d)", "scp error: peer sent error confirmation (code: %d)",

170
src/wolfsftp.c
View File

@ -1041,8 +1041,7 @@ int wolfSSH_SFTP_accept(WOLFSSH* ssh)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
ssh->sftpState = SFTP_RECV; ssh->sftpState = SFTP_RECV;
FALL_THROUGH; NO_BREAK;
/* no break */
case SFTP_RECV: case SFTP_RECV:
if (SFTP_ServerSendInit(ssh) != WS_SUCCESS) { if (SFTP_ServerSendInit(ssh) != WS_SUCCESS) {
@ -1273,8 +1272,7 @@ int wolfSSH_SFTP_read(WOLFSSH* ssh)
ssh->reqId = state->reqId; ssh->reqId = state->reqId;
state->state = STATE_RECV_DO; state->state = STATE_RECV_DO;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_RECV_DO: case STATE_RECV_DO:
ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer, ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer,
@ -1428,8 +1426,7 @@ int wolfSSH_SFTP_read(WOLFSSH* ssh)
} }
state->buffer.idx = 0; state->buffer.idx = 0;
state->state = STATE_RECV_SEND; state->state = STATE_RECV_SEND;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_RECV_SEND: case STATE_RECV_SEND:
if (state->toSend) { if (state->toSend) {
@ -4698,8 +4695,7 @@ static int SFTP_ClientRecvInit(WOLFSSH* ssh) {
sz = sz - MSG_ID_SZ - UINT32_SZ; sz = sz - MSG_ID_SZ - UINT32_SZ;
ssh->sftpExtSz = sz; ssh->sftpExtSz = sz;
ssh->sftpState = SFTP_EXT; ssh->sftpState = SFTP_EXT;
FALL_THROUGH; NO_BREAK;
/* no break */
case SFTP_EXT: case SFTP_EXT:
/* silently ignore extensions if not supported */ /* silently ignore extensions if not supported */
@ -4791,8 +4787,7 @@ int wolfSSH_SFTP_connect(WOLFSSH* ssh)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
ssh->sftpState = SFTP_RECV; ssh->sftpState = SFTP_RECV;
FALL_THROUGH; NO_BREAK;
/* no break */
case SFTP_RECV: case SFTP_RECV:
case SFTP_EXT: case SFTP_EXT:
@ -4904,8 +4899,7 @@ int SendPacketType(WOLFSSH* ssh, byte type, byte* buf, word32 bufSz)
wolfSSH_SFTP_buffer_rewind(&state->buffer); wolfSSH_SFTP_buffer_rewind(&state->buffer);
} }
state->state = SFTP_SEND_PACKET; state->state = SFTP_SEND_PACKET;
FALL_THROUGH; NO_BREAK;
/* no break */
case SFTP_SEND_PACKET: case SFTP_SEND_PACKET:
/* send header and type specific state->data, looping over send /* send header and type specific state->data, looping over send
@ -5361,8 +5355,7 @@ static WS_SFTPNAME* wolfSSH_SFTP_DoName(WOLFSSH* ssh)
wolfSSH_SFTP_ClearState(ssh, STATE_ID_NAME); wolfSSH_SFTP_ClearState(ssh, STATE_ID_NAME);
return NULL; return NULL;
} }
FALL_THROUGH; NO_BREAK;
/* no break */
case SFTP_NAME_DO_STATUS: case SFTP_NAME_DO_STATUS:
if (state->state == SFTP_NAME_DO_STATUS) { if (state->state == SFTP_NAME_DO_STATUS) {
@ -5379,8 +5372,7 @@ static WS_SFTPNAME* wolfSSH_SFTP_DoName(WOLFSSH* ssh)
wolfSSH_SFTP_DoStatus(ssh, reqId, &state->buffer); wolfSSH_SFTP_DoStatus(ssh, reqId, &state->buffer);
return NULL; return NULL;
} }
FALL_THROUGH; NO_BREAK;
/* no break */
case SFTP_NAME_GET_PACKET: case SFTP_NAME_GET_PACKET:
@ -5544,7 +5536,7 @@ static int wolfSSH_SFTP_GetHandle(WOLFSSH* ssh, byte* handle, word32* handleSz)
case STATE_GET_HANDLE_INIT: case STATE_GET_HANDLE_INIT:
WLOG(WS_LOG_SFTP, "SFTP GET HANDLE STATE: INIT"); WLOG(WS_LOG_SFTP, "SFTP GET HANDLE STATE: INIT");
state->state = STATE_GET_HANDLE_GET_HEADER; state->state = STATE_GET_HANDLE_GET_HEADER;
FALL_THROUGH; NO_BREAK;
case STATE_GET_HANDLE_GET_HEADER: case STATE_GET_HANDLE_GET_HEADER:
WLOG(WS_LOG_SFTP, "SFTP GET HANDLE STATE: GET_HEADER"); WLOG(WS_LOG_SFTP, "SFTP GET HANDLE STATE: GET_HEADER");
@ -5614,7 +5606,7 @@ static int wolfSSH_SFTP_GetHandle(WOLFSSH* ssh, byte* handle, word32* handleSz)
ssh->reqId++; ssh->reqId++;
state->state = STATE_GET_HANDLE_READ; state->state = STATE_GET_HANDLE_READ;
FALL_THROUGH; NO_BREAK;
case STATE_GET_HANDLE_READ: case STATE_GET_HANDLE_READ:
WLOG(WS_LOG_SFTP, "SFTP GET HANDLE STATE: READ"); WLOG(WS_LOG_SFTP, "SFTP GET HANDLE STATE: READ");
@ -5642,7 +5634,7 @@ static int wolfSSH_SFTP_GetHandle(WOLFSSH* ssh, byte* handle, word32* handleSz)
(wolfSSH_SFTP_buffer_data(&state->buffer) + UINT32_SZ), (wolfSSH_SFTP_buffer_data(&state->buffer) + UINT32_SZ),
*handleSz); *handleSz);
state->state = STATE_GET_HANDLE_CLEANUP; state->state = STATE_GET_HANDLE_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_GET_HANDLE_CLEANUP: case STATE_GET_HANDLE_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP GET HANDLE STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP GET HANDLE STATE: CLEANUP");
@ -5701,8 +5693,7 @@ WS_SFTPNAME* wolfSSH_SFTP_LS(WOLFSSH* ssh, char* dir)
return NULL; return NULL;
} }
state->state = STATE_LS_OPENDIR; state->state = STATE_LS_OPENDIR;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_LS_OPENDIR: case STATE_LS_OPENDIR:
if (wolfSSH_SFTP_OpenDir(ssh, (byte*)state->name->fName, if (wolfSSH_SFTP_OpenDir(ssh, (byte*)state->name->fName,
@ -5717,8 +5708,7 @@ WS_SFTPNAME* wolfSSH_SFTP_LS(WOLFSSH* ssh, char* dir)
wolfSSH_SFTPNAME_list_free(state->name); state->name = NULL; wolfSSH_SFTPNAME_list_free(state->name); state->name = NULL;
state->sz = WOLFSSH_MAX_HANDLE; state->sz = WOLFSSH_MAX_HANDLE;
state->state = STATE_LS_GETHANDLE; state->state = STATE_LS_GETHANDLE;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_LS_GETHANDLE: case STATE_LS_GETHANDLE:
/* get the handle from opening the directory and read with it */ /* get the handle from opening the directory and read with it */
@ -5731,8 +5721,7 @@ WS_SFTPNAME* wolfSSH_SFTP_LS(WOLFSSH* ssh, char* dir)
return NULL; return NULL;
} }
state->state = STATE_LS_READDIR; state->state = STATE_LS_READDIR;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_LS_READDIR: case STATE_LS_READDIR:
/* now read the dir */ /* now read the dir */
@ -5745,8 +5734,7 @@ WS_SFTPNAME* wolfSSH_SFTP_LS(WOLFSSH* ssh, char* dir)
/* fall through because the handle should always be closed */ /* fall through because the handle should always be closed */
} }
state->state = STATE_LS_CLOSE; state->state = STATE_LS_CLOSE;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_LS_CLOSE: case STATE_LS_CLOSE:
/* close dir when finished */ /* close dir when finished */
@ -5819,8 +5807,7 @@ int wolfSSH_SFTP_CHMOD(WOLFSSH* ssh, char* n, char* oct)
/* update permissions */ /* update permissions */
state->atr.per = mode; state->atr.per = mode;
state->state = STATE_CHMOD_SEND; state->state = STATE_CHMOD_SEND;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_CHMOD_SEND: case STATE_CHMOD_SEND:
ret = wolfSSH_SFTP_SetSTAT(ssh, n, &state->atr); ret = wolfSSH_SFTP_SetSTAT(ssh, n, &state->atr);
@ -5877,7 +5864,7 @@ static int SFTP_STAT(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr, byte type)
WLOG(WS_LOG_SFTP, "SFTP LSTAT STATE: INIT"); WLOG(WS_LOG_SFTP, "SFTP LSTAT STATE: INIT");
state->dirSz = (word32)WSTRLEN(dir); state->dirSz = (word32)WSTRLEN(dir);
state->state = STATE_LSTAT_SEND_TYPE_REQ; state->state = STATE_LSTAT_SEND_TYPE_REQ;
FALL_THROUGH; NO_BREAK;
case STATE_LSTAT_SEND_TYPE_REQ: case STATE_LSTAT_SEND_TYPE_REQ:
WLOG(WS_LOG_SFTP, "SFTP LSTAT STATE: SEND_TYPE_REQ"); WLOG(WS_LOG_SFTP, "SFTP LSTAT STATE: SEND_TYPE_REQ");
@ -5892,7 +5879,7 @@ static int SFTP_STAT(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr, byte type)
} }
} }
state->state = STATE_LSTAT_GET_HEADER; state->state = STATE_LSTAT_GET_HEADER;
FALL_THROUGH; NO_BREAK;
case STATE_LSTAT_GET_HEADER: case STATE_LSTAT_GET_HEADER:
WLOG(WS_LOG_SFTP, "SFTP LSTAT STATE: GET_HEADER"); WLOG(WS_LOG_SFTP, "SFTP LSTAT STATE: GET_HEADER");
@ -5915,7 +5902,7 @@ static int SFTP_STAT(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr, byte type)
ssh->error = WS_MEMORY_E; ssh->error = WS_MEMORY_E;
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
FALL_THROUGH; NO_BREAK;
case STATE_LSTAT_CHECK_REQ_ID: case STATE_LSTAT_CHECK_REQ_ID:
/* check request ID */ /* check request ID */
@ -5927,7 +5914,7 @@ static int SFTP_STAT(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr, byte type)
ssh->reqId++; ssh->reqId++;
} }
state->state = STATE_LSTAT_PARSE_REPLY; state->state = STATE_LSTAT_PARSE_REPLY;
FALL_THROUGH; NO_BREAK;
case STATE_LSTAT_PARSE_REPLY: case STATE_LSTAT_PARSE_REPLY:
ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer, ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer,
@ -5973,7 +5960,7 @@ static int SFTP_STAT(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr, byte type)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
state->state = STATE_LSTAT_CLEANUP; state->state = STATE_LSTAT_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_LSTAT_CLEANUP: case STATE_LSTAT_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP LSTAT STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP LSTAT STATE: CLEANUP");
@ -6090,8 +6077,7 @@ int wolfSSH_SFTP_SetSTAT(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr)
wolfSSH_SFTP_buffer_rewind(&state->buffer); wolfSSH_SFTP_buffer_rewind(&state->buffer);
state->state = STATE_SET_ATR_SEND; state->state = STATE_SET_ATR_SEND;
FALL_THROUGH; NO_BREAK;
/* no break */
/* send header and type specific data */ /* send header and type specific data */
case STATE_SET_ATR_SEND: case STATE_SET_ATR_SEND:
@ -6103,9 +6089,7 @@ int wolfSSH_SFTP_SetSTAT(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
state->state = STATE_SET_ATR_GET; state->state = STATE_SET_ATR_GET;
wolfSSH_SFTP_buffer_free(ssh, &state->buffer); NO_BREAK;
FALL_THROUGH;
/* no break */
case STATE_SET_ATR_GET: case STATE_SET_ATR_GET:
@ -6131,8 +6115,7 @@ int wolfSSH_SFTP_SetSTAT(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr)
} }
state->state = STATE_SET_ATR_STATUS; state->state = STATE_SET_ATR_STATUS;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_SET_ATR_STATUS: case STATE_SET_ATR_STATUS:
@ -6246,7 +6229,7 @@ int wolfSSH_SFTP_Open(WOLFSSH* ssh, char* dir, word32 reason,
wolfSSH_SFTP_buffer_rewind(&state->buffer); wolfSSH_SFTP_buffer_rewind(&state->buffer);
state->state = STATE_OPEN_SEND; state->state = STATE_OPEN_SEND;
FALL_THROUGH; NO_BREAK;
case STATE_OPEN_SEND: case STATE_OPEN_SEND:
WLOG(WS_LOG_SFTP, "SFTP OPEN STATE: SEND"); WLOG(WS_LOG_SFTP, "SFTP OPEN STATE: SEND");
@ -6263,7 +6246,7 @@ int wolfSSH_SFTP_Open(WOLFSSH* ssh, char* dir, word32 reason,
} }
wolfSSH_SFTP_buffer_free(ssh, &state->buffer); wolfSSH_SFTP_buffer_free(ssh, &state->buffer);
state->state = STATE_OPEN_GETHANDLE; state->state = STATE_OPEN_GETHANDLE;
FALL_THROUGH; NO_BREAK;
case STATE_OPEN_GETHANDLE: case STATE_OPEN_GETHANDLE:
WLOG(WS_LOG_SFTP, "SFTP OPEN STATE: GETHANDLE"); WLOG(WS_LOG_SFTP, "SFTP OPEN STATE: GETHANDLE");
@ -6278,7 +6261,7 @@ int wolfSSH_SFTP_Open(WOLFSSH* ssh, char* dir, word32 reason,
} }
} }
state->state = STATE_OPEN_CLEANUP; state->state = STATE_OPEN_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_OPEN_CLEANUP: case STATE_OPEN_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP OPEN STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP OPEN STATE: CLEANUP");
@ -6379,7 +6362,7 @@ int wolfSSH_SFTP_SendWritePacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
wolfSSH_SFTP_buffer_rewind(&state->buffer); wolfSSH_SFTP_buffer_rewind(&state->buffer);
state->state = STATE_SEND_WRITE_SEND_HEADER; state->state = STATE_SEND_WRITE_SEND_HEADER;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_WRITE_SEND_HEADER: case STATE_SEND_WRITE_SEND_HEADER:
WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: SEND_HEADER"); WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: SEND_HEADER");
@ -6394,7 +6377,7 @@ int wolfSSH_SFTP_SendWritePacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
continue; continue;
} }
state->state = STATE_SEND_WRITE_SEND_BODY; state->state = STATE_SEND_WRITE_SEND_BODY;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_WRITE_SEND_BODY: case STATE_SEND_WRITE_SEND_BODY:
WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: SEND_BODY"); WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: SEND_BODY");
@ -6417,7 +6400,7 @@ int wolfSSH_SFTP_SendWritePacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
} }
wolfSSH_SFTP_buffer_free(ssh, &state->buffer); wolfSSH_SFTP_buffer_free(ssh, &state->buffer);
state->state = STATE_SEND_WRITE_GET_HEADER; state->state = STATE_SEND_WRITE_GET_HEADER;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_WRITE_GET_HEADER: case STATE_SEND_WRITE_GET_HEADER:
WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: GET_HEADER"); WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: GET_HEADER");
@ -6460,7 +6443,7 @@ int wolfSSH_SFTP_SendWritePacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
continue; continue;
} }
state->state = STATE_SEND_WRITE_READ_STATUS; state->state = STATE_SEND_WRITE_READ_STATUS;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_WRITE_READ_STATUS: case STATE_SEND_WRITE_READ_STATUS:
WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: READ_STATUS"); WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: READ_STATUS");
@ -6476,7 +6459,7 @@ int wolfSSH_SFTP_SendWritePacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
} }
wolfSSH_SFTP_buffer_rewind(&state->buffer); wolfSSH_SFTP_buffer_rewind(&state->buffer);
state->state = STATE_SEND_WRITE_DO_STATUS; state->state = STATE_SEND_WRITE_DO_STATUS;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_WRITE_DO_STATUS: case STATE_SEND_WRITE_DO_STATUS:
WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: DO_STATUS"); WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: DO_STATUS");
@ -6492,7 +6475,7 @@ int wolfSSH_SFTP_SendWritePacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
if (ret >= WS_SUCCESS) if (ret >= WS_SUCCESS)
ret = state->sentSz; ret = state->sentSz;
state->state = STATE_SEND_WRITE_CLEANUP; state->state = STATE_SEND_WRITE_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_WRITE_CLEANUP: case STATE_SEND_WRITE_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP SEND_WRITE STATE: CLEANUP");
@ -6596,7 +6579,7 @@ int wolfSSH_SFTP_SendReadPacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
state->state = STATE_SEND_READ_SEND_REQ; state->state = STATE_SEND_READ_SEND_REQ;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_READ_SEND_REQ: case STATE_SEND_READ_SEND_REQ:
WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: SEND_REQ"); WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: SEND_REQ");
@ -6612,7 +6595,7 @@ int wolfSSH_SFTP_SendReadPacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
} }
wolfSSH_SFTP_buffer_free(ssh, &state->buffer); wolfSSH_SFTP_buffer_free(ssh, &state->buffer);
state->state = STATE_SEND_READ_GET_HEADER; state->state = STATE_SEND_READ_GET_HEADER;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_READ_GET_HEADER: case STATE_SEND_READ_GET_HEADER:
WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: GET_HEADER"); WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: GET_HEADER");
@ -6633,7 +6616,7 @@ int wolfSSH_SFTP_SendReadPacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
continue; continue;
} }
state->state = STATE_SEND_READ_CHECK_REQ_ID; state->state = STATE_SEND_READ_CHECK_REQ_ID;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_READ_CHECK_REQ_ID: case STATE_SEND_READ_CHECK_REQ_ID:
WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: CHECK_REQ_ID"); WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: CHECK_REQ_ID");
@ -6680,7 +6663,7 @@ int wolfSSH_SFTP_SendReadPacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
} }
state->state = STATE_SEND_READ_REMAINDER; state->state = STATE_SEND_READ_REMAINDER;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_READ_REMAINDER: case STATE_SEND_READ_REMAINDER:
WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: READ_REMAINDER"); WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: READ_REMAINDER");
@ -6738,7 +6721,7 @@ int wolfSSH_SFTP_SendReadPacket(WOLFSSH* ssh, byte* handle, word32 handleSz,
} }
} }
state->state = STATE_SEND_READ_CLEANUP; state->state = STATE_SEND_READ_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_SEND_READ_CLEANUP: case STATE_SEND_READ_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP SEND_READ STATE: CLEANUP");
@ -6842,8 +6825,7 @@ int wolfSSH_SFTP_MKDIR(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr)
/* free data pointer to reuse it later */ /* free data pointer to reuse it later */
wolfSSH_SFTP_buffer_free(ssh, &state->buffer); wolfSSH_SFTP_buffer_free(ssh, &state->buffer);
state->state = STATE_MKDIR_GET; state->state = STATE_MKDIR_GET;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_MKDIR_GET: case STATE_MKDIR_GET:
/* Get response */ /* Get response */
@ -6875,8 +6857,7 @@ int wolfSSH_SFTP_MKDIR(WOLFSSH* ssh, char* dir, WS_SFTP_FILEATRB* atr)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
state->state = STATE_MKDIR_STATUS; state->state = STATE_MKDIR_STATUS;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_MKDIR_STATUS: case STATE_MKDIR_STATUS:
ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer, ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer,
@ -6945,8 +6926,7 @@ WS_SFTPNAME* wolfSSH_SFTP_ReadDir(WOLFSSH* ssh, byte* handle,
return NULL; return NULL;
} }
state->state = STATE_READDIR_NAME; state->state = STATE_READDIR_NAME;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_READDIR_NAME: case STATE_READDIR_NAME:
name = wolfSSH_SFTP_DoName(ssh); name = wolfSSH_SFTP_DoName(ssh);
@ -6999,7 +6979,7 @@ int wolfSSH_SFTP_Close(WOLFSSH* ssh, byte* handle, word32 handleSz)
case STATE_CLOSE_INIT: case STATE_CLOSE_INIT:
WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: INIT"); WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: INIT");
state->state = STATE_CLOSE_SEND; state->state = STATE_CLOSE_SEND;
FALL_THROUGH; NO_BREAK;
case STATE_CLOSE_SEND: case STATE_CLOSE_SEND:
WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: SEND"); WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: SEND");
@ -7014,7 +6994,7 @@ int wolfSSH_SFTP_Close(WOLFSSH* ssh, byte* handle, word32 handleSz)
continue; continue;
} }
state->state = STATE_CLOSE_GET_HEADER; state->state = STATE_CLOSE_GET_HEADER;
FALL_THROUGH; NO_BREAK;
case STATE_CLOSE_GET_HEADER: case STATE_CLOSE_GET_HEADER:
WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: GET_HEADER"); WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: GET_HEADER");
@ -7037,7 +7017,7 @@ int wolfSSH_SFTP_Close(WOLFSSH* ssh, byte* handle, word32 handleSz)
continue; continue;
} }
state->state = STATE_CLOSE_DO_STATUS; state->state = STATE_CLOSE_DO_STATUS;
FALL_THROUGH; NO_BREAK;
case STATE_CLOSE_DO_STATUS: case STATE_CLOSE_DO_STATUS:
WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: DO_STATUS"); WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: DO_STATUS");
@ -7058,7 +7038,7 @@ int wolfSSH_SFTP_Close(WOLFSSH* ssh, byte* handle, word32 handleSz)
else else
ret = WS_FATAL_ERROR; ret = WS_FATAL_ERROR;
state->state = STATE_CLOSE_CLEANUP; state->state = STATE_CLOSE_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_CLOSE_CLEANUP: case STATE_CLOSE_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP CLOSE STATE: CLEANUP");
@ -7102,8 +7082,7 @@ WS_SFTPNAME* wolfSSH_SFTP_RealPath(WOLFSSH* ssh, char* dir)
return NULL; return NULL;
} }
ssh->realState = SFTP_REAL_GET_PACKET; ssh->realState = SFTP_REAL_GET_PACKET;
FALL_THROUGH; NO_BREAK;
/* no break */
case SFTP_REAL_GET_PACKET: case SFTP_REAL_GET_PACKET:
/* read name response from Real Path packet */ /* read name response from Real Path packet */
@ -7177,7 +7156,7 @@ int wolfSSH_SFTP_Rename(WOLFSSH* ssh, const char* old, const char* nw)
case STATE_RENAME_INIT: case STATE_RENAME_INIT:
WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: INIT"); WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: INIT");
FALL_THROUGH; NO_BREAK;
case STATE_RENAME_GET_STAT: case STATE_RENAME_GET_STAT:
WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: GET_STAT"); WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: GET_STAT");
@ -7240,7 +7219,7 @@ int wolfSSH_SFTP_Rename(WOLFSSH* ssh, const char* old, const char* nw)
wolfSSH_SFTP_buffer_rewind(&state->buffer); wolfSSH_SFTP_buffer_rewind(&state->buffer);
state->state = STATE_RENAME_SEND; state->state = STATE_RENAME_SEND;
FALL_THROUGH; NO_BREAK;
case STATE_RENAME_SEND: case STATE_RENAME_SEND:
WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: SEND"); WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: SEND");
@ -7256,7 +7235,7 @@ int wolfSSH_SFTP_Rename(WOLFSSH* ssh, const char* old, const char* nw)
} }
wolfSSH_SFTP_buffer_free(ssh, &state->buffer); wolfSSH_SFTP_buffer_free(ssh, &state->buffer);
state->state = STATE_RENAME_GET_HEADER; state->state = STATE_RENAME_GET_HEADER;
FALL_THROUGH; NO_BREAK;
case STATE_RENAME_GET_HEADER: case STATE_RENAME_GET_HEADER:
WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: GET_HEADER"); WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: GET_HEADER");
@ -7297,7 +7276,7 @@ int wolfSSH_SFTP_Rename(WOLFSSH* ssh, const char* old, const char* nw)
continue; continue;
} }
state->state = STATE_RENAME_READ_STATUS; state->state = STATE_RENAME_READ_STATUS;
FALL_THROUGH; NO_BREAK;
case STATE_RENAME_READ_STATUS: case STATE_RENAME_READ_STATUS:
WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: READ_STATUS"); WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: READ_STATUS");
@ -7313,7 +7292,7 @@ int wolfSSH_SFTP_Rename(WOLFSSH* ssh, const char* old, const char* nw)
} }
wolfSSH_SFTP_buffer_rewind(&state->buffer); wolfSSH_SFTP_buffer_rewind(&state->buffer);
state->state = STATE_RENAME_DO_STATUS; state->state = STATE_RENAME_DO_STATUS;
FALL_THROUGH; NO_BREAK;
case STATE_RENAME_DO_STATUS: case STATE_RENAME_DO_STATUS:
WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: DO_STATUS"); WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: DO_STATUS");
@ -7331,7 +7310,7 @@ int wolfSSH_SFTP_Rename(WOLFSSH* ssh, const char* old, const char* nw)
ret = WS_FATAL_ERROR; ret = WS_FATAL_ERROR;
} }
state->state = STATE_RENAME_CLEANUP; state->state = STATE_RENAME_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_RENAME_CLEANUP: case STATE_RENAME_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP RENAME STATE: CLEANUP");
@ -7397,8 +7376,7 @@ int wolfSSH_SFTP_Remove(WOLFSSH* ssh, char* f)
return ret; return ret;
} }
state->state = STATE_RM_SEND; state->state = STATE_RM_SEND;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_RM_SEND: case STATE_RM_SEND:
ret = SendPacketType(ssh, WOLFSSH_FTP_REMOVE, (byte*)f, ret = SendPacketType(ssh, WOLFSSH_FTP_REMOVE, (byte*)f,
@ -7410,8 +7388,7 @@ int wolfSSH_SFTP_Remove(WOLFSSH* ssh, char* f)
return ret; return ret;
} }
state->state = STATE_RM_GET; state->state = STATE_RM_GET;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_RM_GET: case STATE_RM_GET:
ret = SFTP_GetHeader(ssh, &state->reqId, &type, &state->buffer); ret = SFTP_GetHeader(ssh, &state->reqId, &type, &state->buffer);
@ -7428,8 +7405,7 @@ int wolfSSH_SFTP_Remove(WOLFSSH* ssh, char* f)
return WS_FATAL_ERROR; return WS_FATAL_ERROR;
} }
state->state = STATE_RM_DOSTATUS; state->state = STATE_RM_DOSTATUS;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_RM_DOSTATUS: case STATE_RM_DOSTATUS:
ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer, ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer,
@ -7502,8 +7478,7 @@ int wolfSSH_SFTP_RMDIR(WOLFSSH* ssh, char* dir)
return ret; return ret;
} }
state->state = STATE_RMDIR_GET; state->state = STATE_RMDIR_GET;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_RMDIR_GET: case STATE_RMDIR_GET:
ret = SFTP_GetHeader(ssh, &state->reqId, &type, &state->buffer); ret = SFTP_GetHeader(ssh, &state->reqId, &type, &state->buffer);
@ -7519,8 +7494,7 @@ int wolfSSH_SFTP_RMDIR(WOLFSSH* ssh, char* dir)
return WS_MEMORY_E; return WS_MEMORY_E;
} }
state->state = STATE_RMDIR_STATUS; state->state = STATE_RMDIR_STATUS;
FALL_THROUGH; NO_BREAK;
/* no break */
case STATE_RMDIR_STATUS: case STATE_RMDIR_STATUS:
ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer, ret = wolfSSH_SFTP_buffer_read(ssh, &state->buffer,
@ -7725,7 +7699,7 @@ int wolfSSH_SFTP_Get(WOLFSSH* ssh, char* from,
case STATE_GET_INIT: case STATE_GET_INIT:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: INIT"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: INIT");
state->state = STATE_GET_LSTAT; state->state = STATE_GET_LSTAT;
FALL_THROUGH; NO_BREAK;
case STATE_GET_LSTAT: case STATE_GET_LSTAT:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: LSTAT"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: LSTAT");
@ -7740,7 +7714,7 @@ int wolfSSH_SFTP_Get(WOLFSSH* ssh, char* from,
} }
state->handleSz = WOLFSSH_MAX_HANDLE; state->handleSz = WOLFSSH_MAX_HANDLE;
state->state = STATE_GET_OPEN_REMOTE; state->state = STATE_GET_OPEN_REMOTE;
FALL_THROUGH; NO_BREAK;
case STATE_GET_OPEN_REMOTE: case STATE_GET_OPEN_REMOTE:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: OPEN REMOTE"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: OPEN REMOTE");
@ -7757,7 +7731,7 @@ int wolfSSH_SFTP_Get(WOLFSSH* ssh, char* from,
continue; continue;
} }
state->state = STATE_GET_LOOKUP_OFFSET; state->state = STATE_GET_LOOKUP_OFFSET;
FALL_THROUGH; NO_BREAK;
case STATE_GET_LOOKUP_OFFSET: case STATE_GET_LOOKUP_OFFSET:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: LOOKUP OFFSET"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: LOOKUP OFFSET");
@ -7766,7 +7740,7 @@ int wolfSSH_SFTP_Get(WOLFSSH* ssh, char* from,
wolfSSH_SFTP_GetOfst(ssh, from, to, state->gOfst); wolfSSH_SFTP_GetOfst(ssh, from, to, state->gOfst);
} }
state->state = STATE_GET_OPEN_LOCAL; state->state = STATE_GET_OPEN_LOCAL;
FALL_THROUGH; NO_BREAK;
case STATE_GET_OPEN_LOCAL: case STATE_GET_OPEN_LOCAL:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: OPEN LOCAL"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: OPEN LOCAL");
@ -7798,7 +7772,7 @@ int wolfSSH_SFTP_Get(WOLFSSH* ssh, char* from,
continue; continue;
} }
state->state = STATE_GET_READ; state->state = STATE_GET_READ;
FALL_THROUGH; NO_BREAK;
case STATE_GET_READ: case STATE_GET_READ:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: GET READ"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: GET READ");
@ -7861,7 +7835,7 @@ int wolfSSH_SFTP_Get(WOLFSSH* ssh, char* from,
} }
ssh->sftpInt = 0; ssh->sftpInt = 0;
state->state = STATE_GET_CLOSE_REMOTE; state->state = STATE_GET_CLOSE_REMOTE;
FALL_THROUGH; NO_BREAK;
case STATE_GET_CLOSE_REMOTE: case STATE_GET_CLOSE_REMOTE:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: CLOSE REMOTE"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: CLOSE REMOTE");
@ -7875,7 +7849,7 @@ int wolfSSH_SFTP_Get(WOLFSSH* ssh, char* from,
WLOG(WS_LOG_SFTP, "Error closing remote handle"); WLOG(WS_LOG_SFTP, "Error closing remote handle");
} }
state->state = STATE_GET_CLOSE_LOCAL; state->state = STATE_GET_CLOSE_LOCAL;
FALL_THROUGH; NO_BREAK;
case STATE_GET_CLOSE_LOCAL: case STATE_GET_CLOSE_LOCAL:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: CLOSE LOCAL"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: CLOSE LOCAL");
@ -7889,7 +7863,7 @@ int wolfSSH_SFTP_Get(WOLFSSH* ssh, char* from,
} }
#endif /* USE_WINDOWS_API */ #endif /* USE_WINDOWS_API */
state->state = STATE_GET_CLEANUP; state->state = STATE_GET_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_GET_CLEANUP: case STATE_GET_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP GET STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP GET STATE: CLEANUP");
@ -7954,7 +7928,7 @@ int wolfSSH_SFTP_Put(WOLFSSH* ssh, char* from, char* to, byte resume,
state->pOfst[0] = 0; state->pOfst[0] = 0;
state->pOfst[1] = 0; state->pOfst[1] = 0;
state->state = STATE_PUT_LOOKUP_OFFSET; state->state = STATE_PUT_LOOKUP_OFFSET;
FALL_THROUGH; NO_BREAK;
case STATE_PUT_LOOKUP_OFFSET: case STATE_PUT_LOOKUP_OFFSET:
WLOG(WS_LOG_SFTP, "SFTP PUT STATE: LOOKUP OFFSET"); WLOG(WS_LOG_SFTP, "SFTP PUT STATE: LOOKUP OFFSET");
@ -7964,7 +7938,7 @@ int wolfSSH_SFTP_Put(WOLFSSH* ssh, char* from, char* to, byte resume,
} }
state->handleSz = WOLFSSH_MAX_HANDLE; state->handleSz = WOLFSSH_MAX_HANDLE;
state->state = STATE_PUT_OPEN_LOCAL; state->state = STATE_PUT_OPEN_LOCAL;
FALL_THROUGH; NO_BREAK;
case STATE_PUT_OPEN_LOCAL: case STATE_PUT_OPEN_LOCAL:
WLOG(WS_LOG_SFTP, "SFTP PUT STATE: OPEN LOCAL"); WLOG(WS_LOG_SFTP, "SFTP PUT STATE: OPEN LOCAL");
@ -8003,7 +7977,7 @@ int wolfSSH_SFTP_Put(WOLFSSH* ssh, char* from, char* to, byte resume,
#endif /* USE_WINDOWS_API */ #endif /* USE_WINDOWS_API */
state->rSz = 0; state->rSz = 0;
state->state = STATE_PUT_OPEN_REMOTE; state->state = STATE_PUT_OPEN_REMOTE;
FALL_THROUGH; NO_BREAK;
case STATE_PUT_OPEN_REMOTE: case STATE_PUT_OPEN_REMOTE:
WLOG(WS_LOG_SFTP, "SFTP PUT STATE: OPEN REMOTE"); WLOG(WS_LOG_SFTP, "SFTP PUT STATE: OPEN REMOTE");
@ -8021,7 +7995,7 @@ int wolfSSH_SFTP_Put(WOLFSSH* ssh, char* from, char* to, byte resume,
continue; continue;
} }
state->state = STATE_PUT_WRITE; state->state = STATE_PUT_WRITE;
FALL_THROUGH; NO_BREAK;
case STATE_PUT_WRITE: case STATE_PUT_WRITE:
WLOG(WS_LOG_SFTP, "SFTP PUT STATE: WRITE"); WLOG(WS_LOG_SFTP, "SFTP PUT STATE: WRITE");
@ -8067,7 +8041,7 @@ int wolfSSH_SFTP_Put(WOLFSSH* ssh, char* from, char* to, byte resume,
wolfSSH_SFTP_SaveOfst(ssh, from, to, state->pOfst); wolfSSH_SFTP_SaveOfst(ssh, from, to, state->pOfst);
ssh->sftpInt = 0; ssh->sftpInt = 0;
} }
FALL_THROUGH; NO_BREAK;
case STATE_PUT_CLOSE_LOCAL: case STATE_PUT_CLOSE_LOCAL:
WLOG(WS_LOG_SFTP, "SFTP PUT STATE: CLOSE LOCAL"); WLOG(WS_LOG_SFTP, "SFTP PUT STATE: CLOSE LOCAL");
@ -8077,7 +8051,7 @@ int wolfSSH_SFTP_Put(WOLFSSH* ssh, char* from, char* to, byte resume,
CloseHandle(state->fileHandle); CloseHandle(state->fileHandle);
#endif /* USE_WINDOWS_API */ #endif /* USE_WINDOWS_API */
state->state = STATE_PUT_CLOSE_REMOTE; state->state = STATE_PUT_CLOSE_REMOTE;
FALL_THROUGH; NO_BREAK;
case STATE_PUT_CLOSE_REMOTE: case STATE_PUT_CLOSE_REMOTE:
WLOG(WS_LOG_SFTP, "SFTP PUT STATE: CLOSE REMOTE"); WLOG(WS_LOG_SFTP, "SFTP PUT STATE: CLOSE REMOTE");
@ -8091,7 +8065,7 @@ int wolfSSH_SFTP_Put(WOLFSSH* ssh, char* from, char* to, byte resume,
/* Fall through to cleanup. */ /* Fall through to cleanup. */
} }
state->state = STATE_PUT_CLEANUP; state->state = STATE_PUT_CLEANUP;
FALL_THROUGH; NO_BREAK;
case STATE_PUT_CLEANUP: case STATE_PUT_CLEANUP:
WLOG(WS_LOG_SFTP, "SFTP PUT STATE: CLEANUP"); WLOG(WS_LOG_SFTP, "SFTP PUT STATE: CLEANUP");

8
wolfssh/port.h
View File

@ -1079,13 +1079,13 @@ extern "C" {
/* GCC 7 has new switch() fall-through detection */ /* GCC 7 has new switch() fall-through detection */
#if defined(__GNUC__) && !defined(FALL_THROUGH) #if defined(__GNUC__) && !defined(NO_BREAK)
#if ((__GNUC__ > 7) || ((__GNUC__ == 7) && (__GNUC_MINOR__ >= 1))) #if ((__GNUC__ > 7) || ((__GNUC__ == 7) && (__GNUC_MINOR__ >= 1)))
#define FALL_THROUGH __attribute__ ((fallthrough)) #define NO_BREAK __attribute__ ((fallthrough))
#endif #endif
#endif #endif
#ifndef FALL_THROUGH #ifndef NO_BREAK
#define FALL_THROUGH #define NO_BREAK
#endif #endif